couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/test/test_native_trivial_crud.cxx

@@ -0,0 +1,83 @@
+/* -*- 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.
+ */
+
+#include "test_helper_native.hxx"
+
+std::string
+uniq_id(const std::string& prefix)
+{
+    return fmt::format("{}_{}", prefix, std::chrono::steady_clock::now().time_since_epoch().count());
+}
+
+TEST_CASE("native: upsert document into default collection", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
+    couchbase::cluster_credentials auth{};
+    auth.username = ctx.username;
+    auth.password = ctx.password;
+
+    asio::io_context io;
+
+    couchbase::cluster cluster(io);
+    auto io_thread = std::thread([&io]() { io.run(); });
+
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open(couchbase::origin(auth, connstr), [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open_bucket(ctx.bucket, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        couchbase::document_id id{ ctx.bucket, "_default._default", uniq_id("foo") };
+        const tao::json::value value = {
+            { "a", 1.0 },
+            { "b", 2.0 },
+        };
+        couchbase::operations::upsert_request req{ id, tao::json::to_string(value) };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::upsert_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ec.message());
+        REQUIRE_FALSE(resp.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("seqno=" << resp.token.sequence_number);
+        REQUIRE(resp.token.sequence_number != 0);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}

data/ext/test/test_ruby_trivial_crud.cxx

@@ -0,0 +1,35 @@
+/* -*- 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.
+ */
+
+#include "test_helper_ruby.hxx"
+
+TEST_CASE("ruby: upsert document into default collection", "[ruby]")
+{
+    TEST_PREAMBLE_RUBY;
+    auto ctx = test_context::load_from_environment();
+
+    auto error = ruby.eval_script(ctx, R"(
+backend = Couchbase::Backend.new
+backend.open(CONNECTION_STRING, {username: USERNAME, password: PASSWORD}, {})
+backend.open_bucket(BUCKET, true)
+backend.document_upsert(BUCKET, "_default._default", "foo", 10_000, JSON.generate(foo: "bar"), 0, {})
+backend.close
+)");
+    if (error) {
+        FAIL(error.value());
+    }
+}

data/ext/test/test_ruby_trivial_query.cxx

@@ -0,0 +1,34 @@
+/* -*- 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.
+ */
+
+#include "test_helper_ruby.hxx"
+
+TEST_CASE("ruby: trivial non-data query", "[ruby]")
+{
+    TEST_PREAMBLE_RUBY;
+    auto ctx = test_context::load_from_environment();
+
+    auto error = ruby.eval_script(ctx, R"(
+backend = Couchbase::Backend.new
+backend.open(CONNECTION_STRING, {username: USERNAME, password: PASSWORD}, {})
+backend.document_query('SELECT "ruby rules" AS greeting', {})
+backend.close
+)");
+    if (error) {
+        FAIL(error.value());
+    }
+}

data/ext/third_party/asio/asio/include/asio.hpp

@@ -53,6 +53,34 @@
 #include "asio/dispatch.hpp"
 #include "asio/error.hpp"
 #include "asio/error_code.hpp"
+#include "asio/execution.hpp"
+#include "asio/execution/allocator.hpp"
+#include "asio/execution/any_executor.hpp"
+#include "asio/execution/blocking.hpp"
+#include "asio/execution/blocking_adaptation.hpp"
+#include "asio/execution/bulk_execute.hpp"
+#include "asio/execution/bulk_guarantee.hpp"
+#include "asio/execution/connect.hpp"
+#include "asio/execution/context.hpp"
+#include "asio/execution/context_as.hpp"
+#include "asio/execution/execute.hpp"
+#include "asio/execution/executor.hpp"
+#include "asio/execution/invocable_archetype.hpp"
+#include "asio/execution/mapping.hpp"
+#include "asio/execution/occupancy.hpp"
+#include "asio/execution/operation_state.hpp"
+#include "asio/execution/outstanding_work.hpp"
+#include "asio/execution/prefer_only.hpp"
+#include "asio/execution/receiver.hpp"
+#include "asio/execution/receiver_invocation_error.hpp"
+#include "asio/execution/relationship.hpp"
+#include "asio/execution/schedule.hpp"
+#include "asio/execution/scheduler.hpp"
+#include "asio/execution/sender.hpp"
+#include "asio/execution/set_done.hpp"
+#include "asio/execution/set_error.hpp"
+#include "asio/execution/set_value.hpp"
+#include "asio/execution/start.hpp"
 #include "asio/execution_context.hpp"
 #include "asio/executor.hpp"
 #include "asio/executor_work_guard.hpp"
@@ -93,6 +121,7 @@
 #include "asio/ip/udp.hpp"
 #include "asio/ip/unicast.hpp"
 #include "asio/ip/v6_only.hpp"
+#include "asio/is_applicable_property.hpp"
 #include "asio/is_executor.hpp"
 #include "asio/is_read_buffered.hpp"
 #include "asio/is_write_buffered.hpp"
@@ -100,6 +129,7 @@
 #include "asio/local/connect_pair.hpp"
 #include "asio/local/datagram_protocol.hpp"
 #include "asio/local/stream_protocol.hpp"
+#include "asio/multiple_exceptions.hpp"
 #include "asio/packaged_task.hpp"
 #include "asio/placeholders.hpp"
 #include "asio/posix/basic_descriptor.hpp"
@@ -108,14 +138,19 @@
 #include "asio/posix/descriptor_base.hpp"
 #include "asio/posix/stream_descriptor.hpp"
 #include "asio/post.hpp"
+#include "asio/prefer.hpp"
+#include "asio/query.hpp"
 #include "asio/read.hpp"
 #include "asio/read_at.hpp"
 #include "asio/read_until.hpp"
 #include "asio/redirect_error.hpp"
+#include "asio/require.hpp"
+#include "asio/require_concept.hpp"
 #include "asio/serial_port.hpp"
 #include "asio/serial_port_base.hpp"
 #include "asio/signal_set.hpp"
 #include "asio/socket_base.hpp"
+#include "asio/static_thread_pool.hpp"
 #include "asio/steady_timer.hpp"
 #include "asio/strand.hpp"
 #include "asio/streambuf.hpp"

data/ext/third_party/asio/asio/include/asio/any_io_executor.hpp

@@ -0,0 +1,71 @@
+//
+// any_io_executor.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef ASIO_ANY_IO_EXECUTOR_HPP
+#define ASIO_ANY_IO_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#if defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+# include "asio/executor.hpp"
+#else // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+# include "asio/execution.hpp"
+# include "asio/execution_context.hpp"
+#endif // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+#if defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+typedef executor any_io_executor;
+
+#else // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+/// Polymorphic executor type for use with I/O objects.
+/**
+ * The @c any_io_executor type is a polymorphic executor that supports the set
+ * of properties required by I/O objects. It is defined as the
+ * execution::any_executor class template parameterised as follows:
+ * @code execution::any_executor<
+ *   execution::context_as_t<execution_context&>,
+ *   execution::blocking_t::never_t,
+ *   execution::prefer_only<execution::blocking_t::possibly_t>,
+ *   execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+ *   execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+ *   execution::prefer_only<execution::relationship_t::fork_t>,
+ *   execution::prefer_only<execution::relationship_t::continuation_t>
+ * > @endcode
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef execution::any_executor<...> any_io_executor;
+#else // defined(GENERATING_DOCUMENTATION)
+typedef execution::any_executor<
+    execution::context_as_t<execution_context&>,
+    execution::blocking_t::never_t,
+    execution::prefer_only<execution::blocking_t::possibly_t>,
+    execution::prefer_only<execution::outstanding_work_t::tracked_t>,
+    execution::prefer_only<execution::outstanding_work_t::untracked_t>,
+    execution::prefer_only<execution::relationship_t::fork_t>,
+    execution::prefer_only<execution::relationship_t::continuation_t>
+  > any_io_executor;
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#endif // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_ANY_IO_EXECUTOR_HPP

data/ext/third_party/asio/asio/include/asio/associated_allocator.hpp

@@ -24,12 +24,6 @@
 namespace asio {
 namespace detail {
 
-template <typename>
-struct associated_allocator_check
-{
-  typedef void type;
-};
-
 template <typename T, typename E, typename = void>
 struct associated_allocator_impl
 {
@@ -43,7 +37,7 @@ struct associated_allocator_impl
 
 template <typename T, typename E>
 struct associated_allocator_impl<T, E,
-  typename associated_allocator_check<typename T::allocator_type>::type>
+  typename void_type<typename T::allocator_type>::type>
 {
   typedef typename T::allocator_type type;
 

data/ext/third_party/asio/asio/include/asio/associated_executor.hpp

@@ -17,6 +17,7 @@
 
 #include "asio/detail/config.hpp"
 #include "asio/detail/type_traits.hpp"
+#include "asio/execution/executor.hpp"
 #include "asio/is_executor.hpp"
 #include "asio/system_executor.hpp"
 
@@ -25,18 +26,14 @@
 namespace asio {
 namespace detail {
 
-template <typename>
-struct associated_executor_check
-{
-  typedef void type;
-};
-
 template <typename T, typename E, typename = void>
 struct associated_executor_impl
 {
+  typedef void asio_associated_executor_is_unspecialised;
+
   typedef E type;
 
-  static type get(const T&, const E& e) ASIO_NOEXCEPT
+  static type get(const T&, const E& e = E()) ASIO_NOEXCEPT
   {
     return e;
   }
@@ -44,11 +41,11 @@ struct associated_executor_impl
 
 template <typename T, typename E>
 struct associated_executor_impl<T, E,
-  typename associated_executor_check<typename T::executor_type>::type>
+  typename void_type<typename T::executor_type>::type>
 {
   typedef typename T::executor_type type;
 
-  static type get(const T& t, const E&) ASIO_NOEXCEPT
+  static type get(const T& t, const E& = E()) ASIO_NOEXCEPT
   {
     return t.get_executor();
   }
@@ -77,22 +74,20 @@ struct associated_executor_impl<T, E,
  */
 template <typename T, typename Executor = system_executor>
 struct associated_executor
+#if !defined(GENERATING_DOCUMENTATION)
+  : detail::associated_executor_impl<T, Executor>
+#endif // !defined(GENERATING_DOCUMENTATION)
 {
+#if defined(GENERATING_DOCUMENTATION)
   /// If @c T has a nested type @c executor_type, <tt>T::executor_type</tt>.
   /// Otherwise @c Executor.
-#if defined(GENERATING_DOCUMENTATION)
   typedef see_below type;
-#else // defined(GENERATING_DOCUMENTATION)
-  typedef typename detail::associated_executor_impl<T, Executor>::type type;
-#endif // defined(GENERATING_DOCUMENTATION)
 
   /// If @c T has a nested type @c executor_type, returns
   /// <tt>t.get_executor()</tt>. Otherwise returns @c ex.
   static type get(const T& t,
-      const Executor& ex = Executor()) ASIO_NOEXCEPT
-  {
-    return detail::associated_executor_impl<T, Executor>::get(t, ex);
-  }
+      const Executor& ex = Executor()) ASIO_NOEXCEPT;
+#endif // defined(GENERATING_DOCUMENTATION)
 };
 
 /// Helper function to obtain an object's associated executor.
@@ -113,8 +108,9 @@ get_associated_executor(const T& t) ASIO_NOEXCEPT
 template <typename T, typename Executor>
 inline typename associated_executor<T, Executor>::type
 get_associated_executor(const T& t, const Executor& ex,
-    typename enable_if<is_executor<
-      Executor>::value>::type* = 0) ASIO_NOEXCEPT
+    typename enable_if<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type* = 0) ASIO_NOEXCEPT
 {
   return associated_executor<T, Executor>::get(t, ex);
 }
@@ -142,6 +138,27 @@ using associated_executor_t = typename associated_executor<T, Executor>::type;
 
 #endif // defined(ASIO_HAS_ALIAS_TEMPLATES)
 
+namespace detail {
+
+template <typename T, typename E, typename = void>
+struct associated_executor_forwarding_base
+{
+};
+
+template <typename T, typename E>
+struct associated_executor_forwarding_base<T, E,
+    typename enable_if<
+      is_same<
+        typename associated_executor<T,
+          E>::asio_associated_executor_is_unspecialised,
+        void
+      >::value
+    >::type>
+{
+  typedef void asio_associated_executor_is_unspecialised;
+};
+
+} // namespace detail
 } // namespace asio
 
 #include "asio/detail/pop_options.hpp"

data/ext/third_party/asio/asio/include/asio/async_result.hpp

@@ -512,12 +512,6 @@ ASIO_CONCEPT completion_token_for =
 
 namespace detail {
 
-template <typename>
-struct default_completion_token_check
-{
-  typedef void type;
-};
-
 template <typename T, typename = void>
 struct default_completion_token_impl
 {
@@ -526,8 +520,7 @@ struct default_completion_token_impl
 
 template <typename T>
 struct default_completion_token_impl<T,
-  typename default_completion_token_check<
-    typename T::default_completion_token_type>::type>
+  typename void_type<typename T::default_completion_token_type>::type>
 {
   typedef typename T::default_completion_token_type type;
 };