couchbase 3.5.0-x86_64-linux-musl

data/lib/couchbase/protostellar/management/collection_query_index_manager.rb

@@ -0,0 +1,124 @@
+#  Copyright 2023. 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.
+
+# frozen_string_literal: true
+
+require "couchbase/management/query_index_manager"
+
+require_relative "../request_generator/admin/query"
+require_relative "../response_converter/admin/query"
+
+module Couchbase
+  module Protostellar
+    module Management
+      class CollectionQueryIndexManager
+        def initialize(client:, bucket_name:, scope_name:, collection_name:)
+          @client = client
+          @bucket_name = bucket_name
+          @scope_name = scope_name
+          @collection_name = collection_name
+          @request_generator = RequestGenerator::Admin::Query.new(
+            bucket_name: @bucket_name, scope_name: @scope_name, collection_name: @collection_name
+          )
+        end
+
+        def get_all_indexes(options = Couchbase::Management::Options::Query::GetAllIndexes.new)
+          validate_options(options)
+
+          req = @request_generator.get_all_indexes_request(options)
+          resp = @client.send_request(req)
+          ResponseConverter::Admin::Query.to_query_index_array(resp)
+        end
+
+        def create_index(index_name, fields, options = Couchbase::Management::Options::Query::CreateIndex.new)
+          validate_options(options)
+
+          req = @request_generator.create_index_request(index_name, fields, options)
+          @client.send_request(req)
+        end
+
+        def create_primary_index(options = Couchbase::Management::Options::Query::CreatePrimaryIndex.new)
+          validate_options(options)
+
+          req = @request_generator.create_primary_index_request(options)
+          @client.send_request(req)
+        end
+
+        def drop_index(index_name, options = Couchbase::Management::Options::Query::DropIndex.new)
+          validate_options(options)
+
+          req = @request_generator.drop_index_request(index_name, options)
+          @client.send_request(req)
+        end
+
+        def drop_primary_index(options = Couchbase::Management::Options::Query::DropPrimaryIndex.new)
+          validate_options(options)
+
+          req = @request_generator.drop_primary_index_request(options)
+          @client.send_request(req)
+        end
+
+        def build_deferred_indexes(options = Couchbase::Management::Options::Query::BuildDeferredIndexes.new)
+          validate_options(options)
+
+          req = @request_generator.build_deferred_indexes_request(options)
+          @client.send_request(req)
+        end
+
+        def watch_indexes(index_names, timeout, options = Couchbase::Management::Options::Query::WatchIndexes.new)
+          validate_options(options)
+
+          # TODO: Will this be implemented in the gateway instead?
+
+          index_names.append("#primary") if options.watch_primary
+
+          interval_millis = 50
+          deadline = Time.now + (Utils::Time.extract_duration(timeout) * 0.001)
+
+          while Time.now <= deadline
+            get_all_opts = Couchbase::Management::Options::Query::GetAllIndexes.new(timeout: ((deadline - Time.now) * 1000).round)
+            indexes = get_all_indexes(get_all_opts).select { |idx| index_names.include? idx.name }
+            indexes_not_found = index_names - indexes.map(&:name)
+            unless indexes_not_found.empty?
+              raise Couchbase::Error::IndexNotFound,
+                    "Failed to find the indexes: #{indexes_not_found.join(', ')}"
+            end
+
+            all_online = indexes.all? { |idx| idx.state == :online }
+            return if all_online
+
+            sleep(interval_millis / 1000)
+            interval_millis += 500
+            interval_millis = 1000 if interval_millis > 1000
+          end
+          raise Couchbase::Error::UnambiguousTimeout, "Failed to find all indexes online within the allotted time"
+        end
+
+        private
+
+        def validate_options(options)
+          unless options.scope_name.nil?
+            raise Couchbase::Error::InvalidArgument,
+                  "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          end
+
+          return if options.collection_name.nil?
+
+          raise Couchbase::Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/management/query_index_manager.rb

@@ -0,0 +1,112 @@
+#  Copyright 2023. 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.
+
+# frozen_string_literal: true
+
+require "couchbase/management/query_index_manager"
+
+require_relative "../request_generator/admin/query"
+require_relative "../response_converter/admin/query"
+
+module Couchbase
+  module Protostellar
+    module Management
+      class QueryIndexManager
+        def initialize(client:)
+          @client = client
+          @request_generator = RequestGenerator::Admin::Query.new
+        end
+
+        def get_all_indexes(bucket_name, options = Couchbase::Management::Options::Query::GetAllIndexes.new)
+          validate_options(options)
+
+          req = @request_generator.get_all_indexes_request(options, bucket_name)
+          resp = @client.send_request(req)
+          ResponseConverter::Admin::Query.to_query_index_array(resp)
+        end
+
+        def create_index(bucket_name, index_name, fields, options = Couchbase::Management::Options::Query::CreateIndex.new)
+          validate_options(options)
+
+          req = @request_generator.create_index_request(index_name, fields, options, bucket_name)
+          @client.send_request(req)
+        end
+
+        def create_primary_index(bucket_name, options = Couchbase::Management::Options::Query::CreatePrimaryIndex.new)
+          validate_options(options)
+
+          req = @request_generator.create_primary_index_request(options, bucket_name)
+          @client.send_request(req)
+        end
+
+        def drop_index(bucket_name, index_name, options = Couchbase::Management::Options::Query::DropIndex.new)
+          validate_options(options)
+
+          req = @request_generator.drop_index_request(index_name, options, bucket_name)
+          @client.send_request(req)
+        end
+
+        def drop_primary_index(bucket_name, options = Couchbase::Management::Options::Query::DropPrimaryIndex.new)
+          validate_options(options)
+
+          req = @request_generator.drop_primary_index_request(options, bucket_name)
+          @client.send_request(req)
+        end
+
+        def build_deferred_indexes(bucket_name, options = Couchbase::Management::Options::Query::BuildDeferredIndexes.new)
+          validate_options(options)
+
+          req = @request_generator.build_deferred_indexes_request(options, bucket_name)
+          @client.send_request(req)
+        end
+
+        def watch_indexes(bucket_name, index_names, timeout, options = Couchbase::Management::Options::Query::WatchIndexes.new)
+          validate_options(options)
+
+          # TODO: Will this be implemented in the gateway instead?
+
+          index_names.append("#primary") if options.watch_primary
+
+          interval_millis = 50
+          deadline = Time.now + (Utils::Time.extract_duration(timeout) * 0.001)
+          while Time.now <= deadline
+            get_all_opts = Couchbase::Management::Options::Query::GetAllIndexes.new(timeout: ((deadline - Time.now) * 1000).round)
+            indexes = get_all_indexes(bucket_name, get_all_opts).select { |idx| index_names.include? idx.name }
+            indexes_not_found = index_names - indexes.map(&:name)
+            unless indexes_not_found.empty?
+              raise Couchbase::Error::IndexNotFound,
+                    "Failed to find the indexes: #{indexes_not_found.join(', ')}"
+            end
+
+            all_online = indexes.all? { |idx| idx.state == :online }
+            return if all_online
+
+            sleep(interval_millis / 1000)
+            interval_millis += 500
+            interval_millis = 1000 if interval_millis > 1000
+          end
+          raise Couchbase::Error::UnambiguousTimeout, "Failed to find all indexes online within the allotted time"
+        end
+
+        private
+
+        def validate_options(options)
+          return if options.scope_name.nil? && options.collection_name.nil?
+
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/management.rb

@@ -0,0 +1,24 @@
+#  Copyright 2023. 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.
+
+# frozen_string_literal: true
+
+require_relative "management/collection_manager"
+
+module Couchbase
+  module Protostellar
+    module Management
+    end
+  end
+end

data/lib/couchbase/protostellar/request.rb

@@ -0,0 +1,78 @@
+#  Copyright 2023. 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.
+
+# frozen_string_literal: true
+
+require "couchbase/utils/time"
+require_relative "retry/strategies/best_effort"
+
+module Couchbase
+  module Protostellar
+    # @api private
+    class Request
+      attr_reader :service
+      attr_reader :rpc
+      attr_reader :timeout
+      attr_reader :proto_request
+      attr_reader :idempotent
+      attr_reader :retry_attempts
+      attr_reader :retry_reasons
+      attr_reader :retry_strategy
+      attr_accessor :context
+
+      def initialize(
+        service:,
+        rpc:,
+        proto_request:,
+        timeout:,
+        retry_strategy: Retry::Strategies::BestEffort::DEFAULT,
+        idempotent: false
+      )
+        @service = service
+        @rpc = rpc
+        @timeout = timeout
+        @deadline = nil
+        @proto_request = proto_request
+        @idempotent = idempotent
+        @retry_attempts = 0
+        @retry_reasons = Set.new
+        @retry_strategy = retry_strategy
+        @context = {}
+      end
+
+      def deadline
+        if @deadline.nil?
+          timeout_secs = 0.001 * Utils::Time.extract_duration(@timeout)
+          @deadline = Time.now + timeout_secs
+        end
+        @deadline
+      end
+
+      def add_retry_attempt(reason)
+        @retry_reasons.add(reason)
+        @retry_attempts += 1
+      end
+
+      def error_context
+        @context.merge({retry_reasons: @retry_reasons.to_a, retry_attempts: @retry_attempts})
+      end
+
+      def set_timeout_from_defaults(timeouts)
+        return unless @timeout.nil?
+
+        @timeout = timeouts.timeout_for_request(self)
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/request_behaviour.rb

@@ -0,0 +1,42 @@
+#  Copyright 2023. 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.
+
+# frozen_string_literal: true
+
+module Couchbase
+  module Protostellar
+    # @api private
+    class RequestBehaviour
+      attr_reader :retry_duration
+      attr_reader :error
+
+      def initialize(retry_duration: nil, error: nil)
+        @retry_duration = retry_duration
+        @error = error
+      end
+
+      def self.fail(error)
+        RequestBehaviour.new(error: error)
+      end
+
+      def self.retry(retry_duration)
+        RequestBehaviour.new(retry_duration: retry_duration)
+      end
+
+      def self.success
+        RequestBehaviour.new(retry_duration: nil, error: nil)
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/request_generator/admin/bucket.rb

@@ -0,0 +1,124 @@
+#  Copyright 2023. 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.
+
+# frozen_string_literal: true
+
+require_relative "../../request"
+require_relative "../../generated/admin/bucket/v1/bucket_pb"
+require_relative "../kv"
+
+module Couchbase
+  module Protostellar
+    module RequestGenerator
+      module Admin
+        class Bucket
+          BUCKET_TYPE_MAP = {
+            :couchbase => :BUCKET_TYPE_COUCHBASE,
+            :memcached => :BUCKET_TYPE_MEMCACHED,
+            :ephemeral => :BUCKET_TYPE_EPHEMERAL,
+          }.freeze
+
+          EVICTION_MODE_MAP = {
+            :full => :EVICTION_MODE_FULL,
+            :value_only => :EVICTION_MODE_VALUE_ONLY,
+            :no_eviction => :EVICTION_MODE_NONE,
+            :not_recently_used => :EVICTION_MODE_NOT_RECENTLY_USED,
+          }.freeze
+
+          COMPRESSION_MODE_MAP = {
+            :off => :COMPRESSION_MODE_OFF,
+            :passive => :COMPRESSION_MODE_PASSIVE,
+            :active => :COMPRESSION_MODE_ACTIVE,
+          }.freeze
+
+          STORAGE_BACKEND_MAP = {
+            :couchstore => :STORAGE_BACKEND_COUCHSTORE,
+            :magma => :STORAGE_BACKEND_MAGMA,
+          }.freeze
+
+          CONFLICT_RESOLUTION_TYPE_MAP = {
+            :timestamp => :CONFLICT_RESOLUTION_TYPE_TIMESTAMP,
+            :sequence_number => :CONFLICT_RESOLUTION_TYPE_SEQUENCE_NUMBER,
+            :custom => :CONFLICT_RESOLUTION_TYPE_CUSTOM,
+          }.freeze
+
+          DURABILITY_LEVEL_MAP = RequestGenerator::KV::DURABILITY_LEVEL_MAP
+
+          def list_buckets_request(options)
+            proto_req = Generated::Admin::Bucket::V1::ListBucketsRequest.new
+            create_request(proto_req, :list_buckets, options, idempotent: true)
+          end
+
+          def create_bucket_request(settings, options)
+            proto_req = Generated::Admin::Bucket::V1::CreateBucketRequest.new(
+              extract_bucket_settings(settings, create: true)
+            )
+            create_request(proto_req, :create_bucket, options)
+          end
+
+          def update_bucket_request(settings, options)
+            proto_req = Generated::Admin::Bucket::V1::UpdateBucketRequest.new(
+              extract_bucket_settings(settings, create: false)
+            )
+            create_request(proto_req, :update_bucket, options)
+          end
+
+          def delete_bucket_request(bucket_name, options)
+            proto_req = Generated::Admin::Bucket::V1::DeleteBucketRequest.new(
+              bucket_name: bucket_name
+            )
+            create_request(proto_req, :delete_bucket, options)
+          end
+
+          private
+
+          def extract_bucket_settings(settings, create: false)
+            s = {bucket_name: settings.name}
+
+            if create
+              s[:bucket_type] = BUCKET_TYPE_MAP[settings.bucket_type]
+              s[:storage_backend] = STORAGE_BACKEND_MAP[settings.storage_backend] unless settings.storage_backend.nil?
+              unless settings.conflict_resolution_type.nil?
+                s[:conflict_resolution_type] = CONFLICT_RESOLUTION_TYPE_MAP[settings.conflict_resolution_type]
+              end
+              s[:replica_indexes] = settings.replica_indexes unless settings.replica_indexes.nil?
+            end
+
+            s[:ram_quota_mb] = settings.ram_quota_mb unless settings.ram_quota_mb.nil?
+            s[:num_replicas] = settings.num_replicas unless settings.num_replicas.nil?
+            s[:flush_enabled] = settings.flush_enabled unless settings.flush_enabled.nil?
+            s[:eviction_mode] = EVICTION_MODE_MAP[settings.eviction_policy] unless settings.eviction_policy.nil?
+            s[:max_expiry_secs] = settings.max_expiry unless settings.max_expiry.nil?
+            s[:compression_mode] = COMPRESSION_MODE_MAP[settings.compression_mode] unless settings.compression_mode.nil?
+            unless settings.minimum_durability_level.nil?
+              s[:minimum_durability_level] = DURABILITY_LEVEL_MAP[settings.minimum_durability_level]
+            end
+
+            s
+          end
+
+          def create_request(proto_request, rpc, options, idempotent: false)
+            Request.new(
+              service: :bucket_admin,
+              rpc: rpc,
+              proto_request: proto_request,
+              idempotent: idempotent,
+              timeout: options.timeout
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/request_generator/admin/collection.rb

@@ -0,0 +1,94 @@
+#  Copyright 2023. 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.
+
+# frozen_string_literal: true
+
+require "couchbase/protostellar/request"
+require "couchbase/protostellar/generated/admin/collection/v1/collection_pb"
+
+module Couchbase
+  module Protostellar
+    module RequestGenerator
+      module Admin
+        class Collection
+          attr_reader :client
+
+          def initialize(bucket_name:)
+            @bucket_name = bucket_name
+          end
+
+          def list_collections_request(options)
+            proto_req = Generated::Admin::Collection::V1::ListCollectionsRequest.new(
+              bucket_name: @bucket_name
+            )
+            create_request(proto_req, :list_collections, options, idempotent: true)
+          end
+
+          def create_scope_request(scope_name, options)
+            proto_req = Generated::Admin::Collection::V1::CreateScopeRequest.new(
+              bucket_name: @bucket_name,
+              scope_name: scope_name
+            )
+            create_request(proto_req, :create_scope, options)
+          end
+
+          def delete_scope_request(scope_name, options)
+            proto_req = Generated::Admin::Collection::V1::DeleteScopeRequest.new(
+              bucket_name: @bucket_name,
+              scope_name: scope_name
+            )
+            create_request(proto_req, :delete_scope, options)
+          end
+
+          def create_collection_request(scope_name, collection_name, settings, options)
+            proto_opts = {}
+            proto_opts[:max_expiry_secs] = settings.max_expiry unless settings.max_expiry.nil?
+            unless settings.history.nil?
+              raise Couchbase::Error::FeatureNotAvailable, "The #{Protostellar::NAME} protocol does not support the history setting"
+            end
+
+            proto_req = Generated::Admin::Collection::V1::CreateCollectionRequest.new(
+              bucket_name: @bucket_name,
+              scope_name: scope_name,
+              collection_name: collection_name,
+              **proto_opts
+            )
+            create_request(proto_req, :create_collection, options)
+          end
+
+          def delete_collection_request(scope_name, collection_name, options)
+            proto_req = Generated::Admin::Collection::V1::DeleteCollectionRequest.new(
+              bucket_name: @bucket_name,
+              scope_name: scope_name,
+              collection_name: collection_name
+            )
+            create_request(proto_req, :delete_collection, options)
+          end
+
+          private
+
+          def create_request(proto_request, rpc, options, idempotent: false)
+            Request.new(
+              service: :collection_admin,
+              rpc: rpc,
+              proto_request: proto_request,
+              idempotent: idempotent,
+              timeout: options.timeout
+            )
+          end
+        end
+      end
+    end
+  end
+end