couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.alpha.2-universal-darwin-19

data/examples/managing_query_indexes.rb

@@ -0,0 +1,63 @@
+require 'couchbase'
+include Couchbase
+
+def measure(msg)
+  start = Time.now
+  yield
+  printf "%s in %.2f seconds\n", msg, Time.now - start
+end
+
+def display_indexes(indexes, bucket_name)
+  puts "There are #{indexes.size} query indexes in the bucket \"#{bucket_name}\":"
+  indexes.each do |index|
+    print "  * [#{index.state}] #{index.name}"
+    if index.primary?
+      print " (primary)"
+    end
+    unless index.index_key.empty?
+      print " on [#{index.index_key.join(", ")}]"
+    end
+    if index.condition
+      print " where #{index.condition}"
+    end
+    puts
+  end
+end
+
+bucket_name = "beer-sample"
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://192.168.42.101", options)
+
+display_indexes(cluster.query_indexes.get_all_indexes(bucket_name), bucket_name)
+
+index_name = "demo_index"
+options = Management::QueryIndexManager::DropIndexOptions.new
+options.ignore_if_does_not_exist = true
+measure("Index \"#{index_name}\" has been dropped") { cluster.query_indexes.drop_index(bucket_name, index_name, options) }
+
+options = Management::QueryIndexManager::CreateIndexOptions.new
+options.ignore_if_exists = true
+options.condition = "abv > 2"
+measure("Index \"#{index_name}\" has been created") { cluster.query_indexes.create_index(bucket_name, index_name, %w[`type` `name`], options) }
+
+options = Management::QueryIndexManager::DropPrimaryIndexOptions.new
+options.ignore_if_does_not_exist = true
+measure("Primary index \"#{bucket_name}\" has been dropped") { cluster.query_indexes.drop_primary_index(bucket_name, options) }
+
+options = Management::QueryIndexManager::CreatePrimaryIndexOptions.new
+options.deferred = true
+measure("Primary index \"#{bucket_name}\" has been created") { cluster.query_indexes.create_primary_index(bucket_name, options) }
+
+display_indexes(cluster.query_indexes.get_all_indexes(bucket_name), bucket_name)
+
+measure("Build of the indexes for \"#{bucket_name}\" has been triggered") { cluster.query_indexes.build_deferred_indexes(bucket_name) }
+
+display_indexes(cluster.query_indexes.get_all_indexes(bucket_name), bucket_name)
+
+options = Management::QueryIndexManager::WatchIndexesOptions.new
+options.watch_primary = true
+measure("Watching for primary index build completion for \"#{bucket_name}\" has been finished") { cluster.query_indexes.watch_indexes(bucket_name, [], 10_000_000, options) }
+
+display_indexes(cluster.query_indexes.get_all_indexes(bucket_name), bucket_name)

data/examples/query.rb

@@ -1,5 +1,4 @@
 require 'couchbase'
-require 'byebug'
 
 include Couchbase
 
@@ -7,11 +6,13 @@ options = Cluster::ClusterOptions.new
 options.authenticate("Administrator", "password")
 cluster = Cluster.connect("couchbase://localhost", options)
 
+cluster.bucket("travel-sample") # this is necessary for 6.0.x
+
 options = Cluster::QueryOptions.new
 options.named_parameters({type: "hotel"})
 options.metrics = true
 res = cluster.query("SELECT * FROM `travel-sample` WHERE type = $type LIMIT 10", options)
 res.rows.each do |row|
-  puts "#{row['country']}. #{row['name']}"
+  puts "#{row["travel-sample"]["country"]}. #{row["travel-sample"]["name"]}"
 end
 puts "Status: #{res.meta_data.status}. Execution time: #{res.meta_data.metrics.execution_time}"

data/examples/query_with_consistency.rb

@@ -0,0 +1,76 @@
+require 'couchbase'
+
+include Couchbase
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+options = Management::QueryIndexManager::CreatePrimaryIndexOptions.new
+options.ignore_if_exists = true
+cluster.query_indexes.create_primary_index("default", options)
+
+collection = cluster.bucket("default").default_collection
+
+# METHOD 1
+#
+# The easiest way to enforce consistency is just set scan_consistency option to :request_plus
+# Note: it waits until all documents queued to be indexed when the request has been receive,
+# will be proceed and stored in the index. Often more granular approach is possible (skip to the next section)
+puts "METHOD 1: using :request_plus"
+
+random_number = rand(0..1_000_000_000)
+collection.upsert("user:#{random_number}", {
+    "name" => ["Brass", "Doorknob"],
+    "email" => "brass.doorknob@example.com",
+    "data" => random_number,
+})
+
+options = Cluster::QueryOptions.new
+options.timeout = 10_000
+options.positional_parameters(["Brass"])
+options.scan_consistency = :request_plus
+res = cluster.query("SELECT name, email, data, META(`default`).id FROM `default` WHERE $1 IN name", options)
+res.rows.each do |row|
+  puts "Name: #{row["name"].join(" ")}, e-mail: #{row["email"]}, data: #{row["data"]}"
+  if row["data"] == random_number
+    puts "--- Found our newly created document!"
+  end
+  if ENV['REMOVE_DOOR_KNOBS']
+    puts "Removing #{row["id"]} (requested via env)"
+    collection.remove(row["id"])
+  end
+end
+
+# METHOD 2
+#
+# More granular and light-weight approach is to use AT_PLUS consistency.
+# The application need to to know exactly which mutation affect the result,
+# and supply mutation tokens from those operations.
+puts "METHOD 2: using MutationState"
+
+random_number = rand(0..1_000_000_000)
+res = collection.upsert("user:#{random_number}", {
+    "name" => ["Brass", "Doorknob"],
+    "email" => "brass.doorknob@example.com",
+    "data" => random_number,
+})
+
+state = MutationState.new(res.mutation_token)
+# state.add(*tokens) could be used to add more tokens
+
+options = Cluster::QueryOptions.new
+options.timeout = 10_000
+options.positional_parameters(["Brass"])
+options.consistent_with(state)
+res = cluster.query("SELECT name, email, data, META(`default`).id FROM `default` WHERE $1 IN name", options)
+res.rows.each do |row|
+  puts "Name: #{row["name"].join(" ")}, e-mail: #{row["email"]}, data: #{row["data"]}"
+  if row["data"] == random_number
+    puts "--- Found our newly created document!"
+  end
+  if ENV['REMOVE_DOOR_KNOBS']
+    puts "Removing #{row["id"]} (requested via env)"
+    collection.remove(row["id"])
+  end
+end

data/examples/subdocument.rb

@@ -7,6 +7,28 @@ cluster = Cluster.connect("couchbase://localhost", options)
 bucket = cluster.bucket("default")
 collection = bucket.default_collection
 
+document = {
+    name: "Douglas Reynholm",
+    email: "douglas@reynholmindustries.com",
+    addresses: {
+        billing: {
+            line1: "123 Any Street",
+            line2: "Anytown",
+            country: "United Kingdom"
+        },
+        delivery: {
+            line1: "123 Any Street",
+            line2: "Anytown",
+            country: "United Kingdom"
+        }
+    },
+    purchases: {
+        complete: [339, 976, 442, 666],
+        abandoned: [157, 42, 999]
+    }
+}
+collection.upsert("customer123", document)
+
 res = collection.mutate_in("customer123", [
     MutateInSpec.dict_upsert("fax", "311-555-0151")
 ])
@@ -19,7 +41,7 @@ res = collection.mutate_in("customer123", [
 ])
 puts "The document has been modified successfully: cas=#{res.cas}"
 
-res = collection.lookup_in"customer123", [
+res = collection.lookup_in "customer123", [
     LookupInSpec.get("addresses.delivery.country"),
     LookupInSpec.exists("purchases.pending[-1]"),
 ]

data/ext/.clang-format

@@ -8,7 +8,7 @@ UseTab: Never
 IndentWidth: 4
 ColumnLimit: 140
 AllowShortFunctionsOnASingleLine: None
-AllowShortBlocksOnASingleLine: false
+AllowShortBlocksOnASingleLine: Empty
 AllowShortCaseLabelsOnASingleLine: false
 BreakBeforeBraces: Linux
 SortIncludes: false

data/ext/.idea/dictionaries/couchbase_terms.xml

@@ -2,7 +2,9 @@
   <dictionary name="couchbase_terms">
     <words>
       <w>dataverse</w>
+      <w>keyspace</w>
       <w>opcode</w>
+      <w>sasl</w>
       <w>subdoc</w>
       <w>upsert</w>
       <w>vbucket</w>

data/ext/.idea/vcs.xml

@@ -6,6 +6,7 @@
     <mapping directory="$PROJECT_DIR$/third_party/gsl" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/third_party/http_parser" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/third_party/json" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/third_party/snappy" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/third_party/spdlog" vcs="Git" />
   </component>
 </project>

data/ext/CMakeLists.txt

@@ -11,6 +11,7 @@ endif()
 add_subdirectory(third_party/gsl)
 add_subdirectory(third_party/json)
 add_subdirectory(third_party/spdlog)
+add_subdirectory(third_party/snappy)
 
 include_directories(BEFORE SYSTEM third_party/gsl/include)
 include_directories(BEFORE SYSTEM third_party/asio/asio/include)
@@ -44,6 +45,13 @@ else()
         target_link_libraries(project_options INTERFACE -fsanitize=address)
     endif()
 
+    option(ENABLE_TSAN "Enable thread sanitizer" FALSE)
+
+    if(ENABLE_TSAN)
+        target_compile_options(project_options INTERFACE -fsanitize=thread)
+        target_link_libraries(project_options INTERFACE -fsanitize=thread)
+    endif()
+
     target_compile_options(
         project_warnings
         INTERFACE -Wall
@@ -107,9 +115,22 @@ else()
     message(STATUS "RUBY_EXECUTABLE: ${RUBY_EXECUTABLE}")
 endif()
 message(STATUS "RUBY_INCLUDE_DIR: ${RUBY_INCLUDE_DIR}")
+message(STATUS "RUBY_LIBRARY: ${RUBY_LIBRARY}")
 include_directories(BEFORE SYSTEM "${RUBY_INCLUDE_DIR}")
 
+find_program(GIT git)
+if(GIT)
+    execute_process(
+        COMMAND git rev-parse HEAD
+        WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        OUTPUT_VARIABLE BACKEND_GIT_REVISION)
+endif()
+
+string(TIMESTAMP BACKEND_BUILD_TIMESTAMP "%Y-%m-%d %H:%M:%S" UTC)
+configure_file(${PROJECT_SOURCE_DIR}/build_version.hxx.in ${PROJECT_BINARY_DIR}/generated/build_version.hxx @ONLY)
 add_library(couchbase SHARED couchbase/couchbase.cxx)
+target_include_directories(couchbase PRIVATE ${PROJECT_BINARY_DIR}/generated)
 target_link_libraries(
     couchbase
     PRIVATE project_options
@@ -120,8 +141,9 @@ target_link_libraries(
             cbcrypto
             cbsasl
             http_parser
+            snappy
             spdlog::spdlog_header_only)
-set_target_properties(cbcrypto cbsasl platform PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set_target_properties(cbcrypto cbsasl platform snappy PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
 
 if(APPLE)
     target_link_options(couchbase PRIVATE -Wl,-undefined,dynamic_lookup)
@@ -130,16 +152,12 @@ else()
 endif()
 
 if(BUILD_EXAMPLES)
+    file(
+        GENERATE
+        OUTPUT ${PROJECT_BINARY_DIR}/generated/generated_config.hxx
+        CONTENT "#pragma once\n#define LIBCOUCHBASE_EXT_PATH \"$<TARGET_FILE:couchbase>\"")
     add_executable(main test/main.cxx)
-    target_link_libraries(
-        main
-        PRIVATE project_options
-                project_warnings
-                OpenSSL::SSL
-                OpenSSL::Crypto
-                platform
-                cbcrypto
-                cbsasl
-                http_parser
-                spdlog::spdlog_header_only)
+    target_include_directories(main PRIVATE ${PROJECT_BINARY_DIR}/generated)
+    target_link_libraries(main PRIVATE project_options project_warnings ${RUBY_LIBRARY} spdlog::spdlog_header_only)
+    add_dependencies(main couchbase)
 endif()

data/ext/build_version.hxx.in

@@ -0,0 +1,26 @@
+/* -*- 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
+
+#define BACKEND_BUILD_TIMESTAMP "@BACKEND_BUILD_TIMESTAMP@"
+#define BACKEND_CXX_COMPILER "@CMAKE_CXX_COMPILER_ID@ @CMAKE_CXX_COMPILER_VERSION@"
+#define BACKEND_C_COMPILER "@CMAKE_C_COMPILER_ID@ @CMAKE_C_COMPILER_VERSION@"
+#define BACKEND_SYSTEM "@CMAKE_SYSTEM@"
+#define BACKEND_SYSTEM_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@"
+#define BACKEND_GIT_REVISION "5b91db73c89347cfb4985490051aea4d82f56c0e"
+

data/ext/couchbase/bucket.hxx

@@ -35,41 +35,102 @@ class bucket
     {
     }
 
+    ~bucket()
+    {
+        close();
+    }
+
     [[nodiscard]] const std::string& name() const
     {
         return name_;
     }
 
-    void set_node(size_t index, std::shared_ptr<io::key_value_session> session)
+    void set_node(size_t index, std::shared_ptr<io::mcbp_session> session)
     {
+        if (closed_) {
+            return;
+        }
+
+        auto session_manifest = session->manifest();
+        if (!manifest_cache_) {
+            if (session_manifest) {
+                manifest_cache_ = session_manifest.value();
+            }
+        } else {
+            if (session_manifest && session_manifest->uid > manifest_cache_->uid) {
+                manifest_cache_ = session->manifest().value();
+            }
+        }
         sessions_.emplace(index, std::move(session));
     }
 
-    [[nodiscard]] std::shared_ptr<io::key_value_session> get_node(size_t index)
+    void remove_node(size_t index)
     {
-        return sessions_.at(index);
+        if (closed_) {
+            return;
+        }
+        sessions_.erase(index);
     }
 
     template<typename Request, typename Handler>
     void execute(Request request, Handler&& handler)
     {
-        auto cmd = std::make_shared<operations::command<Request>>(ctx_, std::move(request));
+        if (closed_) {
+            return;
+        }
         size_t index = 0;
-        std::tie(cmd->request.partition, index) = config_.map_key(request.id.key);
-        cmd->send_to(sessions_.at(index), std::forward<Handler>(handler));
+        std::tie(request.partition, index) = config_.map_key(request.id.key);
+        auto session = sessions_.at(index);
+        if (manifest_cache_) {
+            request.id.collection_uid = get_collection_uid(request.id.collection);
+        } else {
+            if (!request.id.collection.empty() && request.id.collection != "_default._default") {
+                handler(make_response(std::make_error_code(error::common_errc::unsupported_operation), request, {}));
+                return;
+            }
+        }
+        auto cmd = std::make_shared<operations::command<Request>>(ctx_, std::move(request));
+        cmd->send_to(session, std::forward<Handler>(handler));
     }
 
     void close()
     {
+        if (closed_) {
+            return;
+        }
+        closed_ = true;
         for (auto& session : sessions_) {
             session.second->stop();
         }
     }
 
   private:
+    [[nodiscard]] uint32_t get_collection_uid(const std::string& collection_path)
+    {
+        Expects(manifest_cache_.has_value());
+        Expects(!collection_path.empty());
+        auto dot = collection_path.find('.');
+        Expects(dot != std::string::npos);
+        std::string scope = collection_path.substr(0, dot);
+        std::string collection = collection_path.substr(dot + 1);
+        for (const auto& s : manifest_cache_->scopes) {
+            if (s.name == scope) {
+                for (const auto& c : s.collections) {
+                    if (c.name == collection) {
+                        return gsl::narrow_cast<std::uint32_t>(c.uid);
+                    }
+                }
+            }
+        }
+        Ensures(false); // FIXME: return collection not found
+        return 0;
+    }
+
     asio::io_context& ctx_;
     std::string name_;
     configuration config_;
-    std::map<size_t, std::shared_ptr<io::key_value_session>> sessions_;
+    bool closed_{ false };
+    std::optional<collections_manifest> manifest_cache_{};
+    std::map<size_t, std::shared_ptr<io::mcbp_session>> sessions_{};
 };
-} // namespace couchbase
+} // namespace couchbase

data/ext/couchbase/cluster.hxx

@@ -20,11 +20,11 @@
 #include <utility>
 #include <thread>
 
-#include <io/key_value_session.hxx>
+#include <io/mcbp_session.hxx>
 #include <io/session_manager.hxx>
 #include <bucket.hxx>
 #include <operations.hxx>
-#include <operations/query.hxx>
+#include <operations/document_query.hxx>
 
 namespace couchbase
 {
@@ -56,15 +56,14 @@ class cluster
       : id_(uuid::random())
       , ctx_(ctx)
       , work_(asio::make_work_guard(ctx_))
-      , session_(std::make_shared<io::key_value_session>(id_, ctx_))
-      , session_manager_(id_, ctx_)
+      , session_(std::make_shared<io::mcbp_session>(id_, ctx_))
+      , session_manager_(std::make_shared<io::session_manager>(id_, ctx_))
     {
     }
 
     ~cluster()
     {
         work_.reset();
-        close();
     }
 
     template<typename Handler>
@@ -72,16 +71,26 @@ class cluster
     {
         auto address = origin.get_address();
         origin_ = origin;
-        session_->bootstrap(address.first, address.second, origin.get_username(), origin.get_password(), std::forward<Handler>(handler));
-        session_->subscribe_to_configuration_updates([this](const configuration& config) { session_manager_.set_configuration(config); });
+        session_->bootstrap(address.first,
+                            address.second,
+                            origin.get_username(),
+                            origin.get_password(),
+                            [this, handler = std::forward<Handler>(handler)](std::error_code ec, configuration config) mutable {
+                                session_manager_->set_configuration(config);
+                                handler(ec);
+                            });
     }
 
-    void close()
+    template<typename Handler>
+    void close(Handler&& handler)
     {
-        session_->stop();
-        for (auto& bucket : buckets_) {
-            bucket.second.close();
-        }
+        asio::post(asio::bind_executor(ctx_, [this, handler = std::forward<Handler>(handler)]() {
+            session_->stop();
+            for (auto& bucket : buckets_) {
+                bucket.second->close();
+            }
+            handler();
+        }));
     }
 
     template<typename Handler>
@@ -92,38 +101,42 @@ class cluster
         }
         configuration config = session_->config();
         auto& node = config.nodes.front();
-        auto new_session = std::make_shared<io::key_value_session>(id_, ctx_, bucket_name);
-        new_session->bootstrap(node.hostname,
-                               std::to_string(*node.services_plain.key_value),
-                               origin_.get_username(),
-                               origin_.get_password(),
-                               [this, name = bucket_name, new_session, h = std::forward<Handler>(handler)](std::error_code ec) mutable {
-                                   if (!ec) {
-                                       bucket b(ctx_, name, new_session->config());
-                                       size_t this_index = new_session->index();
-                                       if (new_session->config().nodes.size() > 1) {
-                                           for (const auto& n : new_session->config().nodes) {
-                                               if (n.index != this_index) {
-                                                   auto s = std::make_shared<io::key_value_session>(id_, ctx_, name);
-                                                   s->bootstrap(n.hostname,
-                                                                std::to_string(*n.services_plain.key_value),
-                                                                origin_.get_username(),
-                                                                origin_.get_password(),
-                                                                [s, i = n.index, &b](std::error_code err) {
-                                                                    if (err) {
-                                                                        spdlog::warn("unable to bootstrap node: {}", err.message());
-                                                                    } else {
-                                                                        b.set_node(i, s);
-                                                                    }
-                                                                });
+        auto new_session = std::make_shared<io::mcbp_session>(id_, ctx_, bucket_name);
+        new_session->bootstrap(
+          node.hostname,
+          std::to_string(*node.services_plain.key_value),
+          origin_.get_username(),
+          origin_.get_password(),
+          [this, name = bucket_name, new_session, h = std::forward<Handler>(handler)](std::error_code ec, configuration cfg) mutable {
+              if (!ec) {
+                  if (!session_->supports_gcccp()) {
+                      session_manager_->set_configuration(cfg);
+                  }
+                  auto b = std::make_shared<bucket>(ctx_, name, cfg);
+                  size_t this_index = new_session->index();
+                  b->set_node(this_index, new_session);
+                  if (cfg.nodes.size() > 1) {
+                      for (const auto& n : cfg.nodes) {
+                          if (n.index != this_index) {
+                              auto s = std::make_shared<io::mcbp_session>(id_, ctx_, name);
+                              b->set_node(n.index, s);
+                              s->bootstrap(n.hostname,
+                                           std::to_string(*n.services_plain.key_value),
+                                           origin_.get_username(),
+                                           origin_.get_password(),
+                                           [s, i = n.index, b](std::error_code err, configuration /*config*/) {
+                                               if (err) {
+                                                   spdlog::warn("unable to bootstrap node: {}", err.message());
+                                                   b->remove_node(i);
                                                }
-                                           }
-                                       }
-                                       b.set_node(this_index, std::move(new_session));
-                                       buckets_.emplace(name, std::move(b));
-                                   }
-                                   h(ec);
-                               });
+                                           });
+                          }
+                      }
+                  }
+                  buckets_.emplace(name, std::move(b));
+              }
+              h(ec);
+          });
     }
 
     template<class Request, class Handler>
@@ -133,17 +146,20 @@ class cluster
         if (bucket == buckets_.end()) {
             return handler(operations::make_response(std::make_error_code(error::common_errc::bucket_not_found), request, {}));
         }
-        return bucket->second.execute(request, std::forward<Handler>(handler));
+        return bucket->second->execute(request, std::forward<Handler>(handler));
     }
 
-    template<class Handler>
-    void execute(operations::query_request request, Handler&& handler)
+    template<class Request, class Handler>
+    void execute_http(Request request, Handler&& handler)
     {
-        auto session = session_manager_.check_out(service_type::query, origin_.username, origin_.password);
-        auto cmd = std::make_shared<operations::command<operations::query_request>>(ctx_, std::move(request));
-        cmd->send_to(session, [this, session, handler = std::forward<Handler>(handler)](operations::query_response resp) mutable {
+        auto session = session_manager_->check_out(Request::type, origin_.username, origin_.password);
+        if (!session) {
+            return handler(operations::make_response(std::make_error_code(error::common_errc::service_not_available), request, {}));
+        }
+        auto cmd = std::make_shared<operations::command<Request>>(ctx_, std::move(request));
+        cmd->send_to(session, [this, session, handler = std::forward<Handler>(handler)](typename Request::response_type resp) mutable {
             handler(std::move(resp));
-            session_manager_.check_in(service_type::query, session);
+            session_manager_->check_in(Request::type, session);
         });
     }
 
@@ -151,9 +167,9 @@ class cluster
     uuid::uuid_t id_;
     asio::io_context& ctx_;
     asio::executor_work_guard<asio::io_context::executor_type> work_;
-    std::shared_ptr<io::key_value_session> session_;
-    io::session_manager session_manager_;
-    std::map<std::string, bucket> buckets_;
+    std::shared_ptr<io::mcbp_session> session_;
+    std::shared_ptr<io::session_manager> session_manager_;
+    std::map<std::string, std::shared_ptr<bucket>> buckets_;
     origin origin_;
 };
-} // namespace couchbase
+} // namespace couchbase