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

data/ext/couchbase/cluster_options.hxx

@@ -0,0 +1,53 @@
+/* -*- 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 <timeout_defaults.hxx>
+
+namespace couchbase
+{
+struct cluster_options {
+    std::chrono::milliseconds bootstrap_timeout = timeout_defaults::bootstrap_timeout;
+    std::chrono::milliseconds connect_timeout = timeout_defaults::connect_timeout;
+    std::chrono::milliseconds key_value_timeout = timeout_defaults::key_value_timeout;
+    std::chrono::milliseconds key_value_durable_timeout = timeout_defaults::key_value_durable_timeout;
+    std::chrono::milliseconds view_timeout = timeout_defaults::view_timeout;
+    std::chrono::milliseconds query_timeout = timeout_defaults::query_timeout;
+    std::chrono::milliseconds analytics_timeout = timeout_defaults::analytics_timeout;
+    std::chrono::milliseconds search_timeout = timeout_defaults::search_timeout;
+    std::chrono::milliseconds management_timeout = timeout_defaults::management_timeout;
+    std::chrono::milliseconds dns_srv_timeout = timeout_defaults::dns_srv_timeout;
+
+    bool enable_tls{ false };
+    std::string trust_certificate{};
+    bool enable_mutation_tokens{ true };
+    bool enable_tcp_keep_alive{ true };
+    bool force_ipv4{ false };
+    bool enable_dns_srv{ true };
+    std::string network{ "auto" };
+
+    std::chrono::milliseconds tcp_keep_alive_interval = timeout_defaults::tcp_keep_alive_interval;
+    std::chrono::milliseconds config_poll_interval = timeout_defaults::config_poll_interval;
+    std::chrono::milliseconds config_poll_floor = timeout_defaults::config_poll_floor;
+    std::chrono::milliseconds config_idle_redial_timeout = timeout_defaults::config_idle_redial_timeout;
+
+    size_t max_http_connections{ 0 };
+    std::chrono::milliseconds idle_http_connection_timeout = timeout_defaults::idle_http_connection_timeout;
+};
+
+} // namespace couchbase

data/ext/couchbase/configuration.hxx

@@ -24,6 +24,8 @@
 #include <utils/crc32.hxx>
 #include <platform/uuid.h>
 
+#include <service_type.hxx>
+
 namespace couchbase
 {
 struct configuration {
@@ -35,14 +37,149 @@ struct configuration {
         std::optional<std::uint16_t> views;
         std::optional<std::uint16_t> query;
     };
+    struct alternate_address {
+        std::string name;
+        std::string hostname;
+        port_map services_plain{};
+        port_map services_tls{};
+    };
     struct node {
         bool this_node{ false };
         size_t index;
         std::string hostname;
         port_map services_plain;
         port_map services_tls;
+        std::map<std::string, alternate_address> alt{};
+
+        [[nodiscard]] std::uint16_t port_or(service_type type, bool is_tls, std::uint16_t default_value) const
+        {
+            if (is_tls) {
+                switch (type) {
+                    case service_type::query:
+                        return services_tls.query.value_or(default_value);
+
+                    case service_type::analytics:
+                        return services_tls.analytics.value_or(default_value);
+
+                    case service_type::search:
+                        return services_tls.search.value_or(default_value);
+
+                    case service_type::views:
+                        return services_tls.views.value_or(default_value);
+
+                    case service_type::management:
+                        return services_tls.management.value_or(default_value);
+
+                    case service_type::kv:
+                        return services_tls.key_value.value_or(default_value);
+                }
+            }
+            switch (type) {
+                case service_type::query:
+                    return services_plain.query.value_or(default_value);
+
+                case service_type::analytics:
+                    return services_plain.analytics.value_or(default_value);
+
+                case service_type::search:
+                    return services_plain.search.value_or(default_value);
+
+                case service_type::views:
+                    return services_plain.views.value_or(default_value);
+
+                case service_type::management:
+                    return services_plain.management.value_or(default_value);
+
+                case service_type::kv:
+                    return services_plain.key_value.value_or(default_value);
+            }
+            return default_value;
+        }
+
+        [[nodiscard]] const std::string & hostname_for(const std::string& network) const
+        {
+            if (network == "default") {
+                return hostname;
+            }
+            const auto& address = alt.find(network);
+            if (address == alt.end()) {
+                spdlog::warn(R"(requested network "{}" is not found, fallback to "default" host)", network);
+                return hostname;
+            }
+            return address->second.hostname;
+        }
+
+        [[nodiscard]] std::uint16_t port_or(const std::string& network, service_type type, bool is_tls, std::uint16_t default_value) const
+        {
+            if (network == "default") {
+                return port_or(type, is_tls, default_value);
+            }
+            const auto& address = alt.find(network);
+            if (address == alt.end()) {
+                spdlog::warn(R"(requested network "{}" is not found, fallback to "default" port of {} service)", network, type);
+                return port_or(type, is_tls, default_value);
+            }
+            if (is_tls) {
+                switch (type) {
+                    case service_type::query:
+                        return address->second.services_tls.query.value_or(default_value);
+
+                    case service_type::analytics:
+                        return address->second.services_tls.analytics.value_or(default_value);
+
+                    case service_type::search:
+                        return address->second.services_tls.search.value_or(default_value);
+
+                    case service_type::views:
+                        return address->second.services_tls.views.value_or(default_value);
+
+                    case service_type::management:
+                        return address->second.services_tls.management.value_or(default_value);
+
+                    case service_type::kv:
+                        return address->second.services_tls.key_value.value_or(default_value);
+                }
+            }
+            switch (type) {
+                case service_type::query:
+                    return address->second.services_plain.query.value_or(default_value);
+
+                case service_type::analytics:
+                    return address->second.services_plain.analytics.value_or(default_value);
+
+                case service_type::search:
+                    return address->second.services_plain.search.value_or(default_value);
+
+                case service_type::views:
+                    return address->second.services_plain.views.value_or(default_value);
+
+                case service_type::management:
+                    return address->second.services_plain.management.value_or(default_value);
+
+                case service_type::kv:
+                    return address->second.services_plain.key_value.value_or(default_value);
+            }
+            return default_value;
+        }
     };
 
+    [[nodiscard]] std::string select_network(const std::string& bootstrap_hostname) const
+    {
+        for (const auto& n : nodes) {
+            if (n.this_node) {
+                if (n.hostname == bootstrap_hostname) {
+                    return "default";
+                }
+                for (const auto& entry : n.alt) {
+                    if (entry.second.hostname == bootstrap_hostname) {
+                        return entry.first;
+                    }
+                }
+            }
+        }
+        return "default";
+    }
+
     using vbucket_map = typename std::vector<std::vector<std::int16_t>>;
 
     std::uint64_t rev{};
@@ -143,12 +280,69 @@ struct fmt::formatter<couchbase::configuration::node> : formatter<std::string> {
         if (node.services_tls.views) {
             tls.push_back(fmt::format("capi={}", *node.services_tls.views));
         }
+        std::vector<std::string> alternate_addresses{};
+        if (!node.alt.empty()) {
+            alternate_addresses.reserve(node.alt.size());
+            for (const auto& entry : node.alt) {
+                std::string network = fmt::format(R"(name="{}", host="{}")", entry.second.name, entry.second.hostname);
+                {
+                    std::vector<std::string> ports;
+                    if (entry.second.services_plain.key_value) {
+                        ports.push_back(fmt::format("kv={}", *entry.second.services_plain.key_value));
+                    }
+                    if (entry.second.services_plain.management) {
+                        ports.push_back(fmt::format("mgmt={}", *entry.second.services_plain.management));
+                    }
+                    if (entry.second.services_plain.analytics) {
+                        ports.push_back(fmt::format("cbas={}", *entry.second.services_plain.analytics));
+                    }
+                    if (entry.second.services_plain.search) {
+                        ports.push_back(fmt::format("fts={}", *entry.second.services_plain.search));
+                    }
+                    if (entry.second.services_plain.query) {
+                        ports.push_back(fmt::format("n1ql={}", *entry.second.services_plain.query));
+                    }
+                    if (entry.second.services_plain.views) {
+                        ports.push_back(fmt::format("capi={}", *entry.second.services_plain.views));
+                    }
+                    if (!ports.empty()) {
+                        network += fmt::format(", plain=({})", fmt::join(ports, ","));
+                    }
+                }
+                {
+                    std::vector<std::string> ports;
+                    if (entry.second.services_tls.key_value) {
+                        ports.push_back(fmt::format("kv={}", *entry.second.services_tls.key_value));
+                    }
+                    if (entry.second.services_tls.management) {
+                        ports.push_back(fmt::format("mgmt={}", *entry.second.services_tls.management));
+                    }
+                    if (entry.second.services_tls.analytics) {
+                        ports.push_back(fmt::format("cbas={}", *entry.second.services_tls.analytics));
+                    }
+                    if (entry.second.services_tls.search) {
+                        ports.push_back(fmt::format("fts={}", *entry.second.services_tls.search));
+                    }
+                    if (entry.second.services_tls.query) {
+                        ports.push_back(fmt::format("n1ql={}", *entry.second.services_tls.query));
+                    }
+                    if (entry.second.services_tls.views) {
+                        ports.push_back(fmt::format("capi={}", *entry.second.services_tls.views));
+                    }
+                    if (!ports.empty()) {
+                        network += fmt::format(", tls=({})", fmt::join(ports, ","));
+                    }
+                }
+                alternate_addresses.emplace_back(network);
+            }
+        }
         format_to(ctx.out(),
-                  R"(#<node:{} hostname={}, plain=({}), tls=({})>)",
+                  R"(#<node:{} hostname="{}", plain=({}), tls=({}), alt=[{}]>)",
                   node.index,
                   node.hostname,
                   fmt::join(plain, ", "),
-                  fmt::join(tls, ", "));
+                  fmt::join(tls, ", "),
+                  fmt::join(alternate_addresses, ", "));
         return formatter<std::string>::format("", ctx);
     }
 };
@@ -208,6 +402,30 @@ struct traits<couchbase::configuration> {
             n.services_tls.analytics = s.template optional<std::uint16_t>("cbasSSL");
             n.services_tls.query = s.template optional<std::uint16_t>("n1qlSSL");
             n.services_tls.views = s.template optional<std::uint16_t>("capiSSL");
+            {
+                const auto& alt = o.find("alternateAddresses");
+                if (alt != o.end()) {
+                    for (const auto& entry : alt->second.get_object()) {
+                        couchbase::configuration::alternate_address addr;
+                        addr.name = entry.first;
+                        addr.hostname = entry.second.at("hostname").get_string();
+                        const auto& ports = entry.second.find("ports");
+                        addr.services_plain.key_value = ports->template optional<std::uint16_t>("kv");
+                        addr.services_plain.management = ports->template optional<std::uint16_t>("mgmt");
+                        addr.services_plain.search = ports->template optional<std::uint16_t>("fts");
+                        addr.services_plain.analytics = ports->template optional<std::uint16_t>("cbas");
+                        addr.services_plain.query = ports->template optional<std::uint16_t>("n1ql");
+                        addr.services_plain.views = ports->template optional<std::uint16_t>("capi");
+                        addr.services_tls.key_value = ports->template optional<std::uint16_t>("kvSSL");
+                        addr.services_tls.management = ports->template optional<std::uint16_t>("mgmtSSL");
+                        addr.services_tls.search = ports->template optional<std::uint16_t>("ftsSSL");
+                        addr.services_tls.analytics = ports->template optional<std::uint16_t>("cbasSSL");
+                        addr.services_tls.query = ports->template optional<std::uint16_t>("n1qlSSL");
+                        addr.services_tls.views = ports->template optional<std::uint16_t>("capiSSL");
+                        n.alt.emplace(entry.first, addr);
+                    }
+                }
+            }
             result.nodes.emplace_back(n);
         }
         {

data/ext/couchbase/couchbase.cxx

@@ -15,6 +15,8 @@
  *   limitations under the License.
  */
 
+#include <build_config.hxx>
+
 #include <openssl/crypto.h>
 #include <asio/version.hpp>
 
@@ -106,10 +108,10 @@ cb__backend_close(cb_backend_data* backend)
         auto f = barrier->get_future();
         backend->cluster->close([barrier]() { barrier->set_value(); });
         f.wait();
-        backend->cluster.reset(nullptr);
         if (backend->worker.joinable()) {
             backend->worker.join();
         }
+        backend->cluster.reset(nullptr);
         backend->ctx.reset(nullptr);
     }
 }
@@ -162,7 +164,7 @@ cb_Backend_allocate(VALUE klass)
     return obj;
 }
 
-static VALUE eBackendError;
+static VALUE eCouchbaseError;
 static VALUE eAmbiguousTimeout;
 static VALUE eAuthenticationFailure;
 static VALUE eBucketExists;
@@ -231,70 +233,71 @@ static void
 init_exceptions(VALUE mCouchbase)
 {
     VALUE mError = rb_define_module_under(mCouchbase, "Error");
-    eBackendError = rb_define_class_under(mError, "BackendError", rb_eStandardError);
-    eAmbiguousTimeout = rb_define_class_under(mError, "AmbiguousTimeout", rb_eStandardError);
-    eAuthenticationFailure = rb_define_class_under(mError, "AuthenticationFailure", rb_eStandardError);
-    eBucketExists = rb_define_class_under(mError, "BucketExists", rb_eStandardError);
-    eBucketNotFlushable = rb_define_class_under(mError, "BucketNotFlushable", rb_eStandardError);
-    eBucketNotFound = rb_define_class_under(mError, "BucketNotFound", rb_eStandardError);
-    eCasMismatch = rb_define_class_under(mError, "CasMismatch", rb_eStandardError);
-    eCollectionExists = rb_define_class_under(mError, "CollectionExists", rb_eStandardError);
-    eCollectionNotFound = rb_define_class_under(mError, "CollectionNotFound", rb_eStandardError);
-    eCompilationFailure = rb_define_class_under(mError, "CompilationFailure", rb_eStandardError);
-    eDatasetExists = rb_define_class_under(mError, "DatasetExists", rb_eStandardError);
-    eDatasetNotFound = rb_define_class_under(mError, "DatasetNotFound", rb_eStandardError);
-    eDataverseExists = rb_define_class_under(mError, "DataverseExists", rb_eStandardError);
-    eDataverseNotFound = rb_define_class_under(mError, "DataverseNotFound", rb_eStandardError);
-    eDecodingFailure = rb_define_class_under(mError, "DecodingFailure", rb_eStandardError);
-    eDeltaInvalid = rb_define_class_under(mError, "DeltaInvalid", rb_eStandardError);
-    eDesignDocumentNotFound = rb_define_class_under(mError, "DesignDocumentNotFound", rb_eStandardError);
-    eDocumentExists = rb_define_class_under(mError, "DocumentExists", rb_eStandardError);
-    eDocumentIrretrievable = rb_define_class_under(mError, "DocumentIrretrievable", rb_eStandardError);
-    eDocumentLocked = rb_define_class_under(mError, "DocumentLocked", rb_eStandardError);
-    eDocumentNotFound = rb_define_class_under(mError, "DocumentNotFound", rb_eStandardError);
-    eDocumentNotJson = rb_define_class_under(mError, "DocumentNotJson", rb_eStandardError);
-    eDurabilityAmbiguous = rb_define_class_under(mError, "DurabilityAmbiguous", rb_eStandardError);
-    eDurabilityImpossible = rb_define_class_under(mError, "DurabilityImpossible", rb_eStandardError);
-    eDurabilityLevelNotAvailable = rb_define_class_under(mError, "DurabilityLevelNotAvailable", rb_eStandardError);
-    eDurableWriteInProgress = rb_define_class_under(mError, "DurableWriteInProgress", rb_eStandardError);
-    eDurableWriteReCommitInProgress = rb_define_class_under(mError, "DurableWriteReCommitInProgress", rb_eStandardError);
-    eEncodingFailure = rb_define_class_under(mError, "EncodingFailure", rb_eStandardError);
-    eFeatureNotAvailable = rb_define_class_under(mError, "FeatureNotAvailable", rb_eStandardError);
-    eGroupNotFound = rb_define_class_under(mError, "GroupNotFound", rb_eStandardError);
-    eIndexExists = rb_define_class_under(mError, "IndexExists", rb_eStandardError);
-    eIndexFailure = rb_define_class_under(mError, "IndexFailure", rb_eStandardError);
-    eIndexNotFound = rb_define_class_under(mError, "IndexNotFound", rb_eStandardError);
-    eInternalServerFailure = rb_define_class_under(mError, "InternalServerFailure", rb_eStandardError);
+    eCouchbaseError = rb_define_class_under(mError, "CouchbaseError", rb_eStandardError);
+
+    eAmbiguousTimeout = rb_define_class_under(mError, "AmbiguousTimeout", eCouchbaseError);
+    eAuthenticationFailure = rb_define_class_under(mError, "AuthenticationFailure", eCouchbaseError);
+    eBucketExists = rb_define_class_under(mError, "BucketExists", eCouchbaseError);
+    eBucketNotFlushable = rb_define_class_under(mError, "BucketNotFlushable", eCouchbaseError);
+    eBucketNotFound = rb_define_class_under(mError, "BucketNotFound", eCouchbaseError);
+    eCasMismatch = rb_define_class_under(mError, "CasMismatch", eCouchbaseError);
+    eCollectionExists = rb_define_class_under(mError, "CollectionExists", eCouchbaseError);
+    eCollectionNotFound = rb_define_class_under(mError, "CollectionNotFound", eCouchbaseError);
+    eCompilationFailure = rb_define_class_under(mError, "CompilationFailure", eCouchbaseError);
+    eDatasetExists = rb_define_class_under(mError, "DatasetExists", eCouchbaseError);
+    eDatasetNotFound = rb_define_class_under(mError, "DatasetNotFound", eCouchbaseError);
+    eDataverseExists = rb_define_class_under(mError, "DataverseExists", eCouchbaseError);
+    eDataverseNotFound = rb_define_class_under(mError, "DataverseNotFound", eCouchbaseError);
+    eDecodingFailure = rb_define_class_under(mError, "DecodingFailure", eCouchbaseError);
+    eDeltaInvalid = rb_define_class_under(mError, "DeltaInvalid", eCouchbaseError);
+    eDesignDocumentNotFound = rb_define_class_under(mError, "DesignDocumentNotFound", eCouchbaseError);
+    eDocumentExists = rb_define_class_under(mError, "DocumentExists", eCouchbaseError);
+    eDocumentIrretrievable = rb_define_class_under(mError, "DocumentIrretrievable", eCouchbaseError);
+    eDocumentLocked = rb_define_class_under(mError, "DocumentLocked", eCouchbaseError);
+    eDocumentNotFound = rb_define_class_under(mError, "DocumentNotFound", eCouchbaseError);
+    eDocumentNotJson = rb_define_class_under(mError, "DocumentNotJson", eCouchbaseError);
+    eDurabilityAmbiguous = rb_define_class_under(mError, "DurabilityAmbiguous", eCouchbaseError);
+    eDurabilityImpossible = rb_define_class_under(mError, "DurabilityImpossible", eCouchbaseError);
+    eDurabilityLevelNotAvailable = rb_define_class_under(mError, "DurabilityLevelNotAvailable", eCouchbaseError);
+    eDurableWriteInProgress = rb_define_class_under(mError, "DurableWriteInProgress", eCouchbaseError);
+    eDurableWriteReCommitInProgress = rb_define_class_under(mError, "DurableWriteReCommitInProgress", eCouchbaseError);
+    eEncodingFailure = rb_define_class_under(mError, "EncodingFailure", eCouchbaseError);
+    eFeatureNotAvailable = rb_define_class_under(mError, "FeatureNotAvailable", eCouchbaseError);
+    eGroupNotFound = rb_define_class_under(mError, "GroupNotFound", eCouchbaseError);
+    eIndexExists = rb_define_class_under(mError, "IndexExists", eCouchbaseError);
+    eIndexFailure = rb_define_class_under(mError, "IndexFailure", eCouchbaseError);
+    eIndexNotFound = rb_define_class_under(mError, "IndexNotFound", eCouchbaseError);
+    eInternalServerFailure = rb_define_class_under(mError, "InternalServerFailure", eCouchbaseError);
     eInvalidArgument = rb_define_class_under(mError, "InvalidArgument", rb_eArgError);
-    eJobQueueFull = rb_define_class_under(mError, "JobQueueFull", rb_eStandardError);
-    eLinkNotFound = rb_define_class_under(mError, "LinkNotFound", rb_eStandardError);
-    eNumberTooBig = rb_define_class_under(mError, "NumberTooBig", rb_eStandardError);
-    eParsingFailure = rb_define_class_under(mError, "ParsingFailure", rb_eStandardError);
-    ePathExists = rb_define_class_under(mError, "PathExists", rb_eStandardError);
-    ePathInvalid = rb_define_class_under(mError, "PathInvalid", rb_eStandardError);
-    ePathMismatch = rb_define_class_under(mError, "PathMismatch", rb_eStandardError);
-    ePathNotFound = rb_define_class_under(mError, "PathNotFound", rb_eStandardError);
-    ePathTooBig = rb_define_class_under(mError, "PathTooBig", rb_eStandardError);
-    ePathTooDeep = rb_define_class_under(mError, "PathTooDeep", rb_eStandardError);
-    ePlanningFailure = rb_define_class_under(mError, "PlanningFailure", rb_eStandardError);
-    ePreparedStatementFailure = rb_define_class_under(mError, "PreparedStatementFailure", rb_eStandardError);
-    eRequestCanceled = rb_define_class_under(mError, "RequestCanceled", rb_eStandardError);
-    eScopeExists = rb_define_class_under(mError, "ScopeExists", rb_eStandardError);
-    eScopeNotFound = rb_define_class_under(mError, "ScopeNotFound", rb_eStandardError);
-    eServiceNotAvailable = rb_define_class_under(mError, "ServiceNotAvailable", rb_eStandardError);
-    eTemporaryFailure = rb_define_class_under(mError, "TemporaryFailure", rb_eStandardError);
-    eUnambiguousTimeout = rb_define_class_under(mError, "UnambiguousTimeout", rb_eStandardError);
-    eUnsupportedOperation = rb_define_class_under(mError, "UnsupportedOperation", rb_eStandardError);
-    eUserNotFound = rb_define_class_under(mError, "UserNotFound", rb_eStandardError);
-    eUserExists = rb_define_class_under(mError, "UserExists", rb_eStandardError);
-    eValueInvalid = rb_define_class_under(mError, "ValueInvalid", rb_eStandardError);
-    eValueTooDeep = rb_define_class_under(mError, "ValueTooDeep", rb_eStandardError);
-    eValueTooLarge = rb_define_class_under(mError, "ValueTooLarge", rb_eStandardError);
-    eViewNotFound = rb_define_class_under(mError, "ViewNotFound", rb_eStandardError);
-    eXattrCannotModifyVirtualAttribute = rb_define_class_under(mError, "XattrCannotModifyVirtualAttribute", rb_eStandardError);
-    eXattrInvalidKeyCombo = rb_define_class_under(mError, "XattrInvalidKeyCombo", rb_eStandardError);
-    eXattrUnknownMacro = rb_define_class_under(mError, "XattrUnknownMacro", rb_eStandardError);
-    eXattrUnknownVirtualAttribute = rb_define_class_under(mError, "XattrUnknownVirtualAttribute", rb_eStandardError);
+    eJobQueueFull = rb_define_class_under(mError, "JobQueueFull", eCouchbaseError);
+    eLinkNotFound = rb_define_class_under(mError, "LinkNotFound", eCouchbaseError);
+    eNumberTooBig = rb_define_class_under(mError, "NumberTooBig", eCouchbaseError);
+    eParsingFailure = rb_define_class_under(mError, "ParsingFailure", eCouchbaseError);
+    ePathExists = rb_define_class_under(mError, "PathExists", eCouchbaseError);
+    ePathInvalid = rb_define_class_under(mError, "PathInvalid", eCouchbaseError);
+    ePathMismatch = rb_define_class_under(mError, "PathMismatch", eCouchbaseError);
+    ePathNotFound = rb_define_class_under(mError, "PathNotFound", eCouchbaseError);
+    ePathTooBig = rb_define_class_under(mError, "PathTooBig", eCouchbaseError);
+    ePathTooDeep = rb_define_class_under(mError, "PathTooDeep", eCouchbaseError);
+    ePlanningFailure = rb_define_class_under(mError, "PlanningFailure", eCouchbaseError);
+    ePreparedStatementFailure = rb_define_class_under(mError, "PreparedStatementFailure", eCouchbaseError);
+    eRequestCanceled = rb_define_class_under(mError, "RequestCanceled", eCouchbaseError);
+    eScopeExists = rb_define_class_under(mError, "ScopeExists", eCouchbaseError);
+    eScopeNotFound = rb_define_class_under(mError, "ScopeNotFound", eCouchbaseError);
+    eServiceNotAvailable = rb_define_class_under(mError, "ServiceNotAvailable", eCouchbaseError);
+    eTemporaryFailure = rb_define_class_under(mError, "TemporaryFailure", eCouchbaseError);
+    eUnambiguousTimeout = rb_define_class_under(mError, "UnambiguousTimeout", eCouchbaseError);
+    eUnsupportedOperation = rb_define_class_under(mError, "UnsupportedOperation", eCouchbaseError);
+    eUserNotFound = rb_define_class_under(mError, "UserNotFound", eCouchbaseError);
+    eUserExists = rb_define_class_under(mError, "UserExists", eCouchbaseError);
+    eValueInvalid = rb_define_class_under(mError, "ValueInvalid", eCouchbaseError);
+    eValueTooDeep = rb_define_class_under(mError, "ValueTooDeep", eCouchbaseError);
+    eValueTooLarge = rb_define_class_under(mError, "ValueTooLarge", eCouchbaseError);
+    eViewNotFound = rb_define_class_under(mError, "ViewNotFound", eCouchbaseError);
+    eXattrCannotModifyVirtualAttribute = rb_define_class_under(mError, "XattrCannotModifyVirtualAttribute", eCouchbaseError);
+    eXattrInvalidKeyCombo = rb_define_class_under(mError, "XattrInvalidKeyCombo", eCouchbaseError);
+    eXattrUnknownMacro = rb_define_class_under(mError, "XattrUnknownMacro", eCouchbaseError);
+    eXattrUnknownVirtualAttribute = rb_define_class_under(mError, "XattrUnknownVirtualAttribute", eCouchbaseError);
 }
 
 static VALUE
@@ -503,11 +506,11 @@ cb__map_error_code(std::error_code ec, const std::string& message)
         }
     }
 
-    return rb_exc_new_cstr(eBackendError, fmt::format("{}: {}", message, ec.message()).c_str());
+    return rb_exc_new_cstr(eCouchbaseError, fmt::format("{}: {}", message, ec.message()).c_str());
 }
 
 static VALUE
-cb_Backend_open(VALUE self, VALUE hostname, VALUE username, VALUE password)
+cb_Backend_open(VALUE self, VALUE connection_string, VALUE username, VALUE password, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -515,22 +518,25 @@ cb_Backend_open(VALUE self, VALUE hostname, VALUE username, VALUE password)
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
     }
-    VALUE exc = Qnil;
+    Check_Type(connection_string, T_STRING);
+    Check_Type(username, T_STRING);
+    Check_Type(password, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
+    VALUE exc = Qnil;
     {
-        Check_Type(hostname, T_STRING);
-        Check_Type(username, T_STRING);
-        Check_Type(password, T_STRING);
-
-        couchbase::origin options;
-        options.hostname.assign(RSTRING_PTR(hostname), static_cast<size_t>(RSTRING_LEN(hostname)));
-        options.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
-        options.password.assign(RSTRING_PTR(password), static_cast<size_t>(RSTRING_LEN(password)));
+        std::string input(RSTRING_PTR(connection_string), static_cast<size_t>(RSTRING_LEN(connection_string)));
+        auto connstr = couchbase::utils::parse_connection_string(input);
+        std::string user(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
+        std::string pass(RSTRING_PTR(password), static_cast<size_t>(RSTRING_LEN(password)));
+        couchbase::origin origin(user, pass, std::move(connstr));
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
-        backend->cluster->open(options, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        backend->cluster->open(origin, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
         if (auto ec = f.get()) {
-            exc = cb__map_error_code(ec, fmt::format("unable open cluster at {}", options.hostname));
+            exc = cb__map_error_code(ec, fmt::format("unable open cluster at {}", origin.next_address().first));
         }
     }
     if (!NIL_P(exc)) {
@@ -550,7 +556,7 @@ cb_Backend_close(VALUE self)
 }
 
 static VALUE
-cb_Backend_open_bucket(VALUE self, VALUE bucket)
+cb_Backend_open_bucket(VALUE self, VALUE bucket, VALUE wait_until_ready)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -560,23 +566,28 @@ cb_Backend_open_bucket(VALUE self, VALUE bucket)
     }
 
     Check_Type(bucket, T_STRING);
+    bool wait = RTEST(wait_until_ready);
 
     VALUE exc = Qnil;
     {
         std::string name(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
 
-        auto barrier = std::make_shared<std::promise<std::error_code>>();
-        auto f = barrier->get_future();
-        backend->cluster->open_bucket(name, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
-        if (auto ec = f.get()) {
-            exc = cb__map_error_code(ec, fmt::format("unable open bucket \"{}\"", name));
+        if (wait) {
+            auto barrier = std::make_shared<std::promise<std::error_code>>();
+            auto f = barrier->get_future();
+            backend->cluster->open_bucket(name, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+            if (auto ec = f.get()) {
+                exc = cb__map_error_code(ec, fmt::format("unable open bucket \"{}\"", name));
+            }
+        } else {
+            backend->cluster->open_bucket(name, [](std::error_code) {});
         }
     }
     if (!NIL_P(exc)) {
         rb_exc_raise(exc);
     }
 
-    return Qtrue;
+    return Qnil;
 }
 
 template<typename Request>
@@ -643,7 +654,7 @@ cb_Backend_document_get_projected(VALUE self,
                                   VALUE collection,
                                   VALUE id,
                                   VALUE timeout,
-                                  VALUE with_expiration,
+                                  VALUE with_expiry,
                                   VALUE projections,
                                   VALUE preserve_array_indexes)
 {
@@ -667,7 +678,7 @@ cb_Backend_document_get_projected(VALUE self,
 
         couchbase::operations::get_projected_request req{ doc_id };
         cb__extract_timeout(req, timeout);
-        req.with_expiration = RTEST(with_expiration);
+        req.with_expiry = RTEST(with_expiry);
         req.preserve_array_indexes = RTEST(preserve_array_indexes);
         if (!NIL_P(projections)) {
             Check_Type(projections, T_ARRAY);
@@ -693,8 +704,8 @@ cb_Backend_document_get_projected(VALUE self,
         rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
         rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
         rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
-        if (resp.expiration) {
-            rb_hash_aset(res, rb_id2sym(rb_intern("expiration")), UINT2NUM(resp.expiration.value()));
+        if (resp.expiry) {
+            rb_hash_aset(res, rb_id2sym(rb_intern("expiry")), UINT2NUM(resp.expiry.value()));
         }
         return res;
     } while (false);
@@ -748,7 +759,7 @@ cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VAL
 }
 
 static VALUE
-cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE expiration)
+cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE expiry)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -760,7 +771,7 @@ cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VA
     Check_Type(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
-    Check_Type(expiration, T_FIXNUM);
+    Check_Type(expiry, T_FIXNUM);
 
     VALUE exc = Qnil;
     do {
@@ -771,7 +782,7 @@ cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VA
 
         couchbase::operations::get_and_touch_request req{ doc_id };
         cb__extract_timeout(req, timeout);
-        req.expiration = NUM2UINT(expiration);
+        req.expiry = NUM2UINT(expiry);
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::get_and_touch_response>>();
         auto f = barrier->get_future();
@@ -810,7 +821,7 @@ cb__extract_mutation_result(Response resp)
 }
 
 static VALUE
-cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE expiration)
+cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE expiry)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -822,7 +833,7 @@ cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id,
     Check_Type(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
-    Check_Type(expiration, T_FIXNUM);
+    Check_Type(expiry, T_FIXNUM);
 
     VALUE exc = Qnil;
     do {
@@ -833,7 +844,7 @@ cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id,
 
         couchbase::operations::touch_request req{ doc_id };
         cb__extract_timeout(req, timeout);
-        req.expiration = NUM2UINT(expiration);
+        req.expiry = NUM2UINT(expiry);
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::touch_response>>();
         auto f = barrier->get_future();
@@ -1011,10 +1022,10 @@ cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
                     req.durability_timeout = FIX2UINT(durability_timeout);
                 }
             }
-            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-            if (!NIL_P(expiration)) {
-                Check_Type(expiration, T_FIXNUM);
-                req.expiration = FIX2UINT(expiration);
+            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
+            if (!NIL_P(expiry)) {
+                Check_Type(expiry, T_FIXNUM);
+                req.expiry = FIX2UINT(expiry);
             }
         }
 
@@ -1084,10 +1095,10 @@ cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id
                     req.durability_timeout = FIX2UINT(durability_timeout);
                 }
             }
-            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-            if (!NIL_P(expiration)) {
-                Check_Type(expiration, T_FIXNUM);
-                req.expiration = FIX2UINT(expiration);
+            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
+            if (!NIL_P(expiry)) {
+                Check_Type(expiry, T_FIXNUM);
+                req.expiry = FIX2UINT(expiry);
             }
             VALUE cas = rb_hash_aref(options, rb_id2sym(rb_intern("cas")));
             if (!NIL_P(cas)) {
@@ -1168,10 +1179,10 @@ cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
                     req.durability_timeout = FIX2UINT(durability_timeout);
                 }
             }
-            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-            if (!NIL_P(expiration)) {
-                Check_Type(expiration, T_FIXNUM);
-                req.expiration = FIX2UINT(expiration);
+            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
+            if (!NIL_P(expiry)) {
+                Check_Type(expiry, T_FIXNUM);
+                req.expiry = FIX2UINT(expiry);
             }
         }
 
@@ -1320,10 +1331,10 @@ cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE
                         rb_raise(rb_eArgError, "initial_value must be an Integer");
                 }
             }
-            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-            if (!NIL_P(expiration)) {
-                Check_Type(expiration, T_FIXNUM);
-                req.expiration = FIX2UINT(expiration);
+            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
+            if (!NIL_P(expiry)) {
+                Check_Type(expiry, T_FIXNUM);
+                req.expiry = FIX2UINT(expiry);
             }
         }
 
@@ -1412,10 +1423,10 @@ cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE
                         rb_raise(rb_eArgError, "initial_value must be an Integer");
                 }
             }
-            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-            if (!NIL_P(expiration)) {
-                Check_Type(expiration, T_FIXNUM);
-                req.expiration = FIX2UINT(expiration);
+            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
+            if (!NIL_P(expiry)) {
+                Check_Type(expiry, T_FIXNUM);
+                req.expiry = FIX2UINT(expiry);
             }
         }
 
@@ -1600,7 +1611,7 @@ cb__map_subdoc_status(couchbase::protocol::status status, std::size_t index, con
             rb_hash_aset(
               entry,
               rb_id2sym(rb_intern("error")),
-              rb_exc_new_cstr(eInternalServerFailure,
+              rb_exc_new_cstr(eCouchbaseError,
                               fmt::format("unknown subdocument error status={}, index={}, path={}", status, index, path).c_str()));
             return;
     }
@@ -1762,10 +1773,10 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
                     req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::upsert;
                 }
             }
-            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
-            if (!NIL_P(expiration)) {
-                Check_Type(expiration, T_FIXNUM);
-                req.expiration = FIX2UINT(expiration);
+            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
+            if (!NIL_P(expiry)) {
+                Check_Type(expiry, T_FIXNUM);
+                req.expiry = FIX2UINT(expiry);
             }
             VALUE cas = rb_hash_aref(options, rb_id2sym(rb_intern("cas")));
             if (!NIL_P(cas)) {
@@ -4673,10 +4684,6 @@ cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
         if (!NIL_P(priority)) {
             req.priority = RTEST(priority);
         }
-        VALUE scan_wait = rb_hash_aref(options, rb_id2sym(rb_intern("scan_wait")));
-        if (!NIL_P(scan_wait)) {
-            req.scan_wait = NUM2ULONG(scan_wait);
-        }
         VALUE positional_params = rb_hash_aref(options, rb_id2sym(rb_intern("positional_parameters")));
         if (!NIL_P(positional_params)) {
             Check_Type(positional_params, T_ARRAY);
@@ -5340,9 +5347,9 @@ init_backend(VALUE mCouchbase)
 {
     VALUE cBackend = rb_define_class_under(mCouchbase, "Backend", rb_cBasicObject);
     rb_define_alloc_func(cBackend, cb_Backend_allocate);
-    rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 3);
+    rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 4);
     rb_define_method(cBackend, "close", VALUE_FUNC(cb_Backend_close), 0);
-    rb_define_method(cBackend, "open_bucket", VALUE_FUNC(cb_Backend_open_bucket), 1);
+    rb_define_method(cBackend, "open_bucket", VALUE_FUNC(cb_Backend_open_bucket), 2);
 
     rb_define_method(cBackend, "document_get", VALUE_FUNC(cb_Backend_document_get), 4);
     rb_define_method(cBackend, "document_get_projected", VALUE_FUNC(cb_Backend_document_get_projected), 7);
@@ -5424,7 +5431,7 @@ init_backend(VALUE mCouchbase)
 void
 init_logger()
 {
-    spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %v");
+    spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v");
 
     auto env_val = spdlog::details::os::getenv("COUCHBASE_BACKEND_LOG_LEVEL");
     if (env_val.empty()) {