couchbase 3.9.0-aarch64-linux-musl

data/lib/couchbase/binary_collection.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+#  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 "couchbase/options"
+require "couchbase/binary_collection_options"
+
+module Couchbase
+  # Allows to perform certain operations on non-JSON documents.
+  class BinaryCollection
+    alias inspect to_s
+
+    # @param [Couchbase::Collection] collection parent collection
+    #
+    # @api private
+    def initialize(collection)
+      @collection = collection
+      @backend = collection.instance_variable_get(:@backend)
+      @observability = collection.instance_variable_get(:@observability)
+    end
+
+    # Appends binary content to the document
+    #
+    # @param [String] id the document id which is used to uniquely identify it
+    # @param [String] content the binary content to append to the document
+    # @param [Options::Append] options custom options to customize the request
+    #
+    # @example Append "bar" to the content of the existing document
+    #   collection.upsert("mydoc", "foo")
+    #   collection.binary.append("mydoc", "bar", Options::Append(timeout: 3_000))
+    #   collection.get("mydoc", Options::Get(transcoder: nil)).content #=> "foobar"
+    #
+    # @return [Collection::MutationResult]
+    def append(id, content, options = Options::Append::DEFAULT)
+      @observability.record_operation(Observability::OP_APPEND, options.parent_span, self, :kv) do |obs_handler|
+        obs_handler.add_durability_level(options.durability_level)
+        resp = @backend.document_append(@collection.bucket_name, @collection.scope_name, @collection.name,
+                                        id, content, options.to_backend, obs_handler)
+        Collection::MutationResult.new do |res|
+          res.cas = resp[:cas]
+          res.mutation_token = @collection.send(:extract_mutation_token, resp)
+        end
+      end
+    end
+
+    # Prepends binary content to the document
+    #
+    # @param [String] id the document id which is used to uniquely identify it
+    # @param [String] content the binary content to prepend to the document
+    # @param [Options::Prepend] options custom options to customize the request
+    #
+    # @example Prepend "bar" to the content of the existing document
+    #   collection.upsert("mydoc", "foo")
+    #   collection.binary.prepend("mydoc", "bar", Options::Prepend(timeout: 3_000))
+    #   collection.get("mydoc", Options::Get(transcoder: nil)).content #=> "barfoo"
+    #
+    # @return [Collection::MutationResult]
+    def prepend(id, content, options = Options::Prepend::DEFAULT)
+      @observability.record_operation(Observability::OP_PREPEND, options.parent_span, self, :kv) do |obs_handler|
+        obs_handler.add_durability_level(options.durability_level)
+        resp = @backend.document_prepend(@collection.bucket_name, @collection.scope_name, @collection.name,
+                                         id, content, options.to_backend, obs_handler)
+        Collection::MutationResult.new do |res|
+          res.cas = resp[:cas]
+          res.mutation_token = @collection.send(:extract_mutation_token, resp)
+        end
+      end
+    end
+
+    # Increments the counter document by one of the number defined in the options
+    #
+    # @param [String] id the document id which is used to uniquely identify it
+    # @param [Options::Increment] options custom options to customize the request
+    #
+    # @example Increment value by 10, and initialize to 0 if it does not exist
+    #   res = collection.binary.increment("raw_counter", Options::Increment(delta: 10, initial: 0))
+    #   res.content #=> 0
+    #   res = collection.binary.increment("raw_counter", Options::Increment(delta: 10, initial: 0))
+    #   res.content #=> 10
+    #
+    # @return [CounterResult]
+    def increment(id, options = Options::Increment::DEFAULT)
+      @observability.record_operation(Observability::OP_INCREMENT, options.parent_span, self, :kv) do |obs_handler|
+        obs_handler.add_durability_level(options.durability_level)
+        resp = @backend.document_increment(@collection.bucket_name, @collection.scope_name, @collection.name, id,
+                                           options.to_backend, obs_handler)
+        CounterResult.new do |res|
+          res.cas = resp[:cas]
+          res.content = resp[:content]
+          res.mutation_token = @collection.send(:extract_mutation_token, resp)
+        end
+      end
+    end
+
+    # Decrements the counter document by one of the number defined in the options
+    #
+    # @param [String] id the document id which is used to uniquely identify it
+    # @param [Options::Decrement] options custom options to customize the request
+    #
+    # @example Decrement value by 2, and initialize to 100 if it does not exist
+    #   res = collection.binary.decrement("raw_counter", Options::Decrement(delta: 2, initial: 100))
+    #   res.value #=> 100
+    #   res = collection.binary.decrement("raw_counter", Options::Decrement(delta: 2, initial: 100))
+    #   res.value #=> 98
+    #
+    # @return [CounterResult]
+    def decrement(id, options = Options::Decrement::DEFAULT)
+      @observability.record_operation(Observability::OP_DECREMENT, options.parent_span, self, :kv) do |obs_handler|
+        obs_handler.add_durability_level(options.durability_level)
+        resp = @backend.document_decrement(@collection.bucket_name, @collection.scope_name, @collection.name, id,
+                                           options.to_backend, obs_handler)
+        CounterResult.new do |res|
+          res.cas = resp[:cas]
+          res.content = resp[:content]
+          res.mutation_token = @collection.send(:extract_mutation_token, resp)
+        end
+      end
+    end
+
+    # @api private
+    # TODO: deprecate in 3.1
+    AppendOptions = ::Couchbase::Options::Append
+    # @api private
+    # TODO: deprecate in 3.1
+    PrependOptions = ::Couchbase::Options::Prepend
+    # @api private
+    # TODO: deprecate in 3.1
+    IncrementOptions = ::Couchbase::Options::Increment
+    # @api private
+    # TODO: deprecate in 3.1
+    DecrementOptions = ::Couchbase::Options::Decrement
+  end
+end

data/lib/couchbase/binary_collection_options.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#  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 "couchbase/collection_options"
+
+module Couchbase
+  class BinaryCollection
+    class CounterResult < ::Couchbase::Collection::MutationResult
+      # @return [Integer] current value of the counter
+      attr_accessor :content
+    end
+  end
+end

data/lib/couchbase/bucket.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+#  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 "couchbase/scope"
+require "couchbase/management/collection_manager"
+require "couchbase/management/view_index_manager"
+require "couchbase/options"
+require "couchbase/view_options"
+require "couchbase/diagnostics"
+
+module Couchbase
+  # Provides access to a Couchbase bucket APIs
+  class Bucket
+    # @return [String] name of the bucket
+    attr_reader :name
+
+    alias inspect to_s
+
+    # @param [Couchbase::Backend] backend
+    #
+    # @api private
+    def initialize(backend, name, observability)
+      backend.open_bucket(name, true)
+      @backend = backend
+      @name = name
+      @observability = observability
+    end
+
+    # Get default scope
+    #
+    # @return [Scope]
+    def default_scope
+      Scope.new(@backend, @name, "_default", @observability)
+    end
+
+    # Get a named scope
+    #
+    # @param [String] scope_name name of the scope
+    #
+    # @return [Scope]
+    def scope(scope_name)
+      Scope.new(@backend, @name, scope_name, @observability)
+    end
+
+    # Opens the named collection in the default scope of the bucket
+    #
+    # @param [String] collection_name name of the collection
+    #
+    # @return [Collection]
+    def collection(collection_name)
+      default_scope.collection(collection_name)
+    end
+
+    # Opens the default collection for this bucket
+    #
+    # @return [Collection]
+    def default_collection
+      Collection.new(@backend, @name, "_default", "_default", @observability)
+    end
+
+    # Performs query to view index.
+    #
+    # @param [String] design_document_name name of the design document
+    # @param [String] view_name name of the view to query
+    # @param [Options::View] options
+    #
+    # @example Make sure the view engine catch up with all mutations and return keys starting from +["random_brewery:"]+
+    #   bucket.view_query("beer", "brewery_beers",
+    #                     Options::View(
+    #                       start_key: ["random_brewery:"],
+    #                       scan_consistency: :request_plus
+    #                     ))
+    #
+    # @return [ViewResult]
+    #
+    # @deprecated Views are deprecated in Couchbase Server 7.0+, and will be removed from a future server version.
+    #   Views are not compatible with the Magma storage engine. Instead of views, use indexes and queries using the
+    #   Index Service (GSI) and the Query Service (SQL++).
+    def view_query(design_document_name, view_name, options = Options::View::DEFAULT)
+      @observability.record_operation(Observability::OP_VIEW_QUERY, options.parent_span, self, :views) do |obs_handler|
+        resp = @backend.document_view(@name, design_document_name, view_name, options.namespace, options.to_backend, obs_handler)
+        ViewResult.new do |res|
+          res.meta_data = ViewMetaData.new do |meta|
+            meta.total_rows = resp[:meta][:total_rows]
+            meta.debug_info = resp[:meta][:debug_info]
+          end
+          res.rows = resp[:rows].map do |entry|
+            ViewRow.new do |row|
+              row.id = entry[:id] if entry.key?(:id)
+              row.key = JSON.parse(entry[:key])
+              row.value = JSON.parse(entry[:value])
+            end
+          end
+        end
+      end
+    end
+
+    # @return [Management::CollectionManager]
+    def collections
+      Management::CollectionManager.new(@backend, @name, @observability)
+    end
+
+    # @return [Management::ViewIndexManager]
+    #
+    # @deprecated Views are deprecated in Couchbase Server 7.0+, and will be removed from a future server version.
+    #   Views are not compatible with the Magma storage engine. Instead of views, use indexes and queries using the
+    #   Index Service (GSI) and the Query Service (SQL++).
+    def view_indexes
+      Management::ViewIndexManager.new(@backend, @name, @observability)
+    end
+
+    # Performs application-level ping requests against services in the couchbase cluster
+    #
+    # @param [Options::Ping] options
+    #
+    # @return [PingResult]
+    def ping(options = Options::Ping::DEFAULT)
+      @observability.record_operation(Observability::OP_PING, options.parent_span, self) do |_obs_handler|
+        resp = @backend.ping(@name, options.to_backend)
+        PingResult.new do |res|
+          res.version = resp[:version]
+          res.id = resp[:id]
+          res.sdk = resp[:sdk]
+          resp[:services].each do |type, svcs|
+            res.services[type] = svcs.map do |svc|
+              PingResult::ServiceInfo.new do |info|
+                info.id = svc[:id]
+                info.state = svc[:state]
+                info.latency = svc[:latency]
+                info.remote = svc[:remote]
+                info.local = svc[:local]
+                info.error = svc[:error]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Waits until the bucket reaches the desired state, actively pinging its services
+    #
+    # With +:online+, the wait also requires the bucket's vbucket map to be placed: every vbucket has its active copy
+    # and each replica the data nodes can hold assigned to a node. +:degraded+ only pings.
+    #
+    # +Thread#raise+ does not interrupt the wait. It ends on success, on +timeout+, or when the cluster is disconnected.
+    #
+    # @param [Integer, #in_milliseconds] timeout the maximum time to wait
+    # @param [Options::WaitUntilReady] options
+    #
+    # @return [void]
+    #
+    # @raise [Error::UnambiguousTimeout] if the desired state is not reached within +timeout+
+    # @raise [Error::ClusterClosed] if the cluster has been disconnected
+    # @raise [Error::InvalidArgument] if +timeout+ is negative or longer than 365 days, or +options+ name an
+    #   unsupported desired state or service type
+    def wait_until_ready(timeout, options = Options::WaitUntilReady::DEFAULT)
+      @backend.wait_until_ready(@name, Utils::Time.extract_duration(timeout), options.to_backend)
+    end
+  end
+end