couchbase 4.2.5-dev.3 → 4.2.6-dev

package/README.md

@@ -41,20 +41,92 @@ successfully established.
 Here is a simple example of instantiating a connection, adding a new document
 into the bucket and then retrieving its contents:
 
+**Javascript:**
 ```javascript
-import { Cluster } from 'couchbase'
+const couchbase = require('couchbase')
+
+async function main() {
+  const cluster = await couchbase.connect(
+    'couchbase://127.0.0.1',
+    {
+      username: 'username',
+      password: 'password',
+    })
+
+  const bucket = cluster.bucket('default')
+  const coll = bucket.defaultCollection()
+  await coll.upsert('testdoc', { foo: 'bar' })
+
+  const res = await coll.get('testdoc')
+  console.log(res.content)
+}
+
+// Run the main function
+main()
+  .then((_) => {
+    console.log ('Success!')
+  })
+  .catch((err) => {
+    console.log('ERR:', err)
+  })
+```
 
-const cluster = await couchbase.connect(
-  'couchbase://127.0.0.1',
-  {
-    username: 'username',
-    password: 'password',
+**Typescript:**
+```javascript
+import {
+  Bucket,
+  Cluster,
+  Collection,
+  connect,
+  GetResult,
+} from 'couchbase'
+
+async function main() {
+  const cluster: Cluster = await connect(
+    'couchbase://127.0.0.1',
+    {
+      username: 'username',
+      password: 'password',
+    })
+
+  const bucket: Bucket = cluster.bucket('default')
+  const coll: Collection = bucket.defaultCollection()
+  await coll.upsert('testdoc', { foo: 'bar' })
+
+  const res: GetResult = await coll.get('testdoc')
+  console.log(res.content)
+}
+
+// Run the main function
+main()
+  .then((_) => {
+    console.log ('Success!')
   })
+  .catch((err) => {
+    console.log('ERR:', err)
+  })
+```
+
+## AWS Lambda
+
+Version 4.2.5 of the SDK significantly reduces the size of the prebuilt binary provided with the SDK on supported platforms. The reduction
+enables the SDK to meet the [minimum size requirements](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) for an AWS lambda deployment package without extra steps for reducing the size of the package.  However, if further size reduction is desired, the SDK provides a script to provide recommendations for size reduction.
+
+**Script:**
+```bash
+npm explore couchbase -- npm run help-prune
+```
+
+**Example output:**
+```bash
+Checking for platform packages in /tmp/couchnode-test/node_modules/@couchbase that do not match the expected platform package (couchbase-linux-x64-openssl1).
+Found mismatch: Path=/tmp/couchnode-test/node_modules/@couchbase/couchbase-linuxmusl-x64-openssl1
 
-await coll.upsert('testdoc', { name: 'Frank' })
+Recommendations for pruning:
 
-const res = await coll.get('testdoc')
-console.log(res.content)
+Removing mismatched platform=couchbase-linuxmusl-x64-openssl1 (path=/tmp/couchnode-test/node_modules/@couchbase/couchbase-linuxmusl-x64-openssl1) saves ~13.31 MB on disk.
+Removing Couchbase deps/ (path=/tmp/couchnode-test/node_modules/couchbase/deps) saves ~45.51 MB on disk.
+Removing Couchbase src/ (path=/tmp/couchnode-test/node_modules/couchbase/src) saves ~0.61 MB on disk.
 ```
 
 ## Documentation

package/deps/couchbase-cxx-client/CMakeLists.txt

@@ -100,6 +100,7 @@ set(couchbase_cxx_client_FILES
         core/free_form_http_request.cxx
         core/key_value_config.cxx
         core/n1ql_query_options.cxx
+        core/origin.cxx
         core/range_scan_options.cxx
         core/range_scan_orchestrator.cxx
         core/retry_orchestrator.cxx
@@ -265,10 +266,10 @@ set(couchbase_cxx_client_FILES
         core/impl/boolean_query.cxx
         core/impl/build_deferred_query_indexes.cxx
         core/impl/cluster.cxx
-        core/impl/collection_query_index_manager.cxx
         core/impl/common_error_category.cxx
         core/impl/configuration_profiles_registry.cxx
         core/impl/conjunction_query.cxx
+        core/impl/create_bucket.cxx
         core/impl/create_query_index.cxx
         core/impl/date_range.cxx
         core/impl/date_range_facet.cxx
@@ -277,24 +278,29 @@ set(couchbase_cxx_client_FILES
         core/impl/decrement.cxx
         core/impl/disjunction_query.cxx
         core/impl/dns_srv_tracker.cxx
+        core/impl/drop_bucket.cxx
         core/impl/drop_query_index.cxx
         core/impl/exists.cxx
         core/impl/expiry.cxx
         core/impl/fail_fast_retry_strategy.cxx
         core/impl/field_level_encryption_error_category.cxx
+        core/impl/flush_bucket.cxx
         core/impl/geo_bounding_box_query.cxx
         core/impl/geo_distance_query.cxx
         core/impl/geo_polygon_query.cxx
         core/impl/get.cxx
+        core/impl/get_all_buckets.cxx
         core/impl/get_all_query_indexes.cxx
         core/impl/get_all_replicas.cxx
         core/impl/get_and_lock.cxx
         core/impl/get_and_touch.cxx
         core/impl/get_any_replica.cxx
+        core/impl/get_bucket.cxx
         core/impl/get_replica.cxx
         core/impl/increment.cxx
         core/impl/insert.cxx
         core/impl/internal_date_range_facet_result.cxx
+        core/impl/internal_manager_error_context.cxx
         core/impl/internal_numeric_range_facet_result.cxx
         core/impl/internal_search_error_context.cxx
         core/impl/internal_search_meta_data.cxx
@@ -306,6 +312,7 @@ set(couchbase_cxx_client_FILES
         core/impl/key_value_error_context.cxx
         core/impl/lookup_in.cxx
         core/impl/management_error_category.cxx
+        core/impl/manager_error_context.cxx
         core/impl/match_all_query.cxx
         core/impl/match_none_query.cxx
         core/impl/match_phrase_query.cxx
@@ -368,6 +375,7 @@ set(couchbase_cxx_client_FILES
         core/impl/transaction_get_result.cxx
         core/impl/transaction_op_error_category.cxx
         core/impl/unlock.cxx
+        core/impl/update_bucket.cxx
         core/impl/upsert.cxx
         core/impl/view_error_category.cxx
         core/impl/watch_query_indexes.cxx

package/deps/couchbase-cxx-client/bin/api.rb

@@ -0,0 +1,234 @@
+#  Copyright 2020-2021 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.
+
+require "openssl"
+require "net/http"
+require "json"
+
+class Object
+  def to_b
+    ![nil, false, 0, "", "0", "f", "F", "false", "FALSE", "off", "OFF", "no", "NO"].include?(self)
+  end
+end
+
+
+class API
+  def initialize(options)
+    @options = options
+    connect
+  end
+
+  def connect
+    puts "# CONNECT #{@options}"
+    @client = Net::HTTP.start(@options[:host], @options[:port],
+                              use_ssl: @options[:strict_encryption],
+                              verify_mode: OpenSSL::SSL::VERIFY_NONE)
+  end
+
+  def url(path)
+    "#{@client.use_ssl? ? 'https' : 'http'}://#{@options[:username]}@#{@options[:host]}:#{@options[:port]}#{path}"
+  end
+
+  def decode_response(response)
+    payload =
+      if response['content-type'] =~ /application\/json/
+        JSON.parse(response.body)
+      else
+        response.body
+      end
+    if @options[:verbose]
+      p status: response.code, payload: payload
+    end
+    payload
+  end
+
+  def setup_request(request)
+    request.basic_auth(@options[:username], @options[:password])
+    request['accept'] = "application/json"
+  end
+
+  def get(path)
+    puts "# GET #{url(path)}"
+    req = Net::HTTP::Get.new(path)
+    setup_request(req)
+    res = @client.request(req)
+    decode_response(res)
+  rescue EOFError
+    connect
+    retry
+  rescue => ex
+    puts "#{__method__}: #{ex}, sleep for 1 second and retry"
+    sleep(1)
+    retry
+  end
+
+  def post_form(path, fields = {})
+    puts "# POST #{url(path)} #{fields}"
+    req = Net::HTTP::Post.new(path)
+    setup_request(req)
+    req.form_data = fields
+    res = @client.request(req)
+    decode_response(res)
+  rescue EOFError
+    connect
+    retry
+  rescue => ex
+    puts "#{__method__}: #{ex}, sleep for 1 second and retry"
+    sleep(1)
+    retry
+  end
+
+  def post_json(path, object)
+    data = JSON.generate(object)
+    puts "# POST #{url(path)} #{data}"
+    req = Net::HTTP::Post.new(path)
+    req['content-type'] = "application/json"
+    setup_request(req)
+    res = @client.request(req, data)
+    decode_response(res)
+  rescue EOFError
+    connect
+    retry
+  rescue => ex
+    puts "#{__method__}: #{ex}, sleep for 1 second and retry"
+    sleep(1)
+    retry
+  end
+
+  def put_json(path, object)
+    data = JSON.generate(object)
+    puts "# PUT #{url(path)} #{data}"
+    req = Net::HTTP::Put.new(path)
+    req['content-type'] = "application/json"
+    setup_request(req)
+    res = @client.request(req, data)
+    decode_response(res)
+  rescue EOFError
+    connect
+    retry
+  rescue => ex
+    puts "#{__method__}: #{ex}, sleep for 1 second and retry"
+    sleep(1)
+    retry
+  end
+
+  def delete(path)
+    puts "# DELETE #{url(path)}"
+    req = Net::HTTP::Delete.new(path)
+    setup_request(req)
+    res = @client.request(req)
+    decode_response(res)
+  rescue EOFError
+    connect
+    retry
+  rescue => ex
+    puts "#{__method__}: #{ex}, sleep for 1 second and retry"
+    sleep(1)
+    retry
+  end
+end
+
+def service_address_for_bucket(api, service, bucket, options)
+  port_key = options[:strict_encryption] ? "#{service}SSL" : service
+  host = nil
+  port = 0
+  while port.zero?
+    config = api.get("/pools/default/b/#{bucket}")
+    node_with_service = config["nodesExt"].find{|n| n["services"].key?(port_key)} rescue nil
+    if node_with_service
+      host = node_with_service["hostname"]
+      port = node_with_service["services"][port_key].to_i rescue 0
+    end
+    sleep 1
+  end
+ {host: host || options[:host], port: port}
+end
+
+def ensure_search_index_created(index_definition_path, options)
+  loop do
+    catch :retry do
+      search_api = API.new(options)
+
+      puts "using index definition: #{File.basename(index_definition_path)}"
+      index_definition = JSON.load(File.read(index_definition_path))
+      search_api.put_json("/api/index/travel-sample-index", index_definition)
+
+      expected_number_of_the_documents = 1000
+      indexed_documents = 0
+      times_zero_documents_has_been_seen = 0
+      Timeout.timeout(10 * 60) do # give it 10 minutes to index
+        while indexed_documents < expected_number_of_the_documents
+          resp = search_api.get("/api/index/travel-sample-index/count")
+          indexed_documents = resp['count'].to_i
+          times_zero_documents_has_been_seen += 1 if indexed_documents.zero?
+          if times_zero_documents_has_been_seen >= 60
+            # lets not tolerate 60 seconds of not getting data indexed
+            search_api.delete("/api/index/travel-sample-index")
+            throw :retry
+          end
+          sleep 1
+        end
+      end
+      return
+    end
+  end
+end
+
+def ensure_sample_bucket_loaded(management_api, expected_number_of_the_documents, options)
+  loop do
+    catch :retry do
+      management_api.post_json("/sampleBuckets/install", [options[:bucket]])
+
+      service_address = nil
+      begin
+        Timeout.timeout(60) do # a minute for bucket creation
+          service_address = service_address_for_bucket(management_api, "n1ql", options[:bucket], options)
+        end
+      rescue Timeout::Error
+        management_api.delete("/pools/default/buckets/#{options[:bucket]}")
+        sleep 1
+        throw :retry
+      end
+      puts query_service: service_address
+
+      query_api = API.new(options.merge(service_address))
+      puts "create index for bucket \"#{options[:bucket]}\""
+
+      query_api.post_form("/query/service", statement: "CREATE PRIMARY INDEX ON `#{options[:bucket]}` USING GSI", timeout: "300s")
+
+      indexed_documents = 0
+      times_zero_documents_has_been_seen = 0
+      Timeout.timeout(10 * 60) do # give it 10 minutes to index
+        while indexed_documents < expected_number_of_the_documents
+          resp = query_api.post_form("/query/service", statement: "SELECT RAW COUNT(*) FROM `#{options[:bucket]}`")
+          indexed_documents = resp["results"][0].to_i rescue 0
+
+          if indexed_documents.zero?
+            times_zero_documents_has_been_seen += 1
+            puts times_zero_documents_has_been_seen: times_zero_documents_has_been_seen
+          end
+          if times_zero_documents_has_been_seen >= 60
+            # lets not tolerate 60 seconds of not getting data indexed
+            query_api.post_form("/query/service", statement: "DROP PRIMARY INDEX ON `#{options[:bucket]}`")
+            management_api.delete("/pools/default/buckets/#{options[:bucket]}")
+            sleep 1
+            throw :retry
+          end
+          sleep 1
+        end
+      end
+      return
+    end
+  end
+end

package/deps/couchbase-cxx-client/bin/create-search-index

@@ -15,150 +15,33 @@
 #  limitations under the License.
 
 require "timeout"
-require "net/http"
-require "json"
-require "openssl"
 
-class API
-  def initialize(options)
-    @options = options
-    connect
-  end
-
-  def connect
-    puts "# CONNECT #{@options}"
-    @client = Net::HTTP.start(@options[:host], @options[:port],
-                              use_ssl: @options[:strict_encryption],
-                              verify_mode: OpenSSL::SSL::VERIFY_NONE)
-  end
-
-  def url(path)
-    "#{@client.use_ssl? ? 'https' : 'http'}://#{@options[:username]}@#{@options[:host]}:#{@options[:port]}#{path}"
-  end
-
-  def decode_response(response)
-    payload =
-      if response['content-type'] =~ /application\/json/
-        JSON.parse(response.body)
-      else
-        response.body
-      end
-    p payload if @options[:verbose]
-    payload
-  end
-
-  def setup_request(request)
-    request.basic_auth(@options[:username], @options[:password])
-    request['accept'] = "application/json"
-  end
-
-  def get(path)
-    puts "# GET #{url(path)}"
-    req = Net::HTTP::Get.new(path)
-    setup_request(req)
-    res = @client.request(req)
-    decode_response(res)
-  rescue EOFError
-    connect
-    retry
-  rescue => ex
-    puts "#{__method__}: #{ex}, sleep for 1 second and retry"
-    sleep(1)
-    retry
-  end
-
-  def post_form(path, fields = {})
-    puts "# POST #{url(path)} #{fields}"
-    req = Net::HTTP::Post.new(path)
-    setup_request(req)
-    req.form_data = fields
-    res = @client.request(req)
-    decode_response(res)
-  rescue EOFError
-    connect
-    retry
-  rescue => ex
-    puts "#{__method__}: #{ex}, sleep for 1 second and retry"
-    sleep(1)
-    retry
-  end
-
-  def post_json(path, object)
-    data = JSON.generate(object)
-    puts "# POST #{url(path)} #{data}"
-    req = Net::HTTP::Post.new(path)
-    req['content-type'] = "application/json"
-    setup_request(req)
-    res = @client.request(req, data)
-    decode_response(res)
-  rescue EOFError
-    connect
-    retry
-  rescue => ex
-    puts "#{__method__}: #{ex}, sleep for 1 second and retry"
-    sleep(1)
-    retry
-  end
-
-  def put_json(path, object)
-    data = JSON.generate(object)
-    puts "# PUT #{url(path)} #{data}"
-    req = Net::HTTP::Put.new(path)
-    req['content-type'] = "application/json"
-    setup_request(req)
-    res = @client.request(req, data)
-    decode_response(res)
-  rescue EOFError
-    connect
-    retry
-  rescue => ex
-    puts "#{__method__}: #{ex}, sleep for 1 second and retry"
-    sleep(1)
-    retry
-  end
-end
-
-def service_port_for_bucket(api, service, bucket, options)
-  port_key = options[:strict_encryption] ? "#{service}SSL" : service
-  port = 0
-  while port.zero?
-    config = api.get("/pools/default/b/#{bucket}")
-    port = config["nodesExt"].find{|n| n["services"].key?(port_key)}["services"][port_key].to_i rescue 0
-    sleep 1
-  end
-  port
-end
+require_relative "api"
 
 options = {
-  host: ARGV[0] || "127.0.0.1",
-  strict_encryption: ARGV[1] == "true" || ARGV[1] == "1",
-  username: ARGV[2] || "Administrator",
-  password: ARGV[3] || "password",
+  host: ENV.fetch("CB_HOST", ARGV[0] || "127.0.0.1"),
+  strict_encryption: ENV.fetch("CB_STRICT_ENCRYPTION", ARGV[1]).to_b,
+  username: ENV.fetch("CB_USERNAME", ARGV[2] || "Administrator"),
+  password: ENV.fetch("CB_PASSWORD", ARGV[3] || "password"),
+  verbose: ENV.fetch("CB_VERBOSE", true).to_b,
   bucket: "travel-sample",
-  verbose: true,
 }
 p options: options
 
-management_api = API.new(options.merge(port: options[:strict_encryption] ? 18091 : 8091))
-search_service_port = service_port_for_bucket(management_api, "fts", options[:bucket], options)
+management_api =
+  begin
+    API.new(options.merge(port: options[:strict_encryption] ? 18091 : 8091))
+  rescue => ex
+    puts "#{ex}, sleep for 1 second and retry"
+    sleep(1)
+    retry
+  end
+service_address = service_address_for_bucket(management_api, "fts", options[:bucket], options)
+p search_service: service_address
 
-has_v6_nodes = 
+has_v6_nodes =
   management_api.get("/pools/default")["nodes"]
   .any? { |node| node["version"] =~ /^6\./ && node["services"].include?("fts") }
 
-search_api = API.new(options.merge(port: search_service_port))
 index_definition_path = File.join(__dir__, "travel-sample-index#{"-v6" if has_v6_nodes}.json")
-puts "using index definition: #{File.basename(index_definition_path)}"
-index_definition = JSON.load(File.read(index_definition_path))
-search_api.put_json("/api/index/travel-sample-index", index_definition)
-
-expected_number_of_the_documents = 1000
-indexed_documents = 0
-
-Timeout.timeout(10 * 60) do # give it 10 minutes to index
-  while indexed_documents < expected_number_of_the_documents
-    resp = search_api.get("/api/index/travel-sample-index/count")
-    indexed_documents = resp['count'].to_i
-    sleep 1
-  end
-end
+ensure_search_index_created(index_definition_path, options.merge(service_address))