couchbase 3.9.0-aarch64-linux-musl

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,96 @@
+#  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)
+            unless settings.history.nil?
+              raise Couchbase::Error::FeatureNotAvailable, "The #{Protostellar::NAME} protocol does not support the history setting"
+            end
+            raise Couchbase::Error::InvalidArgument, "max_expiry must be a non-negative integer" if settings.max_expiry&.negative?
+
+            proto_opts = {}
+            proto_opts[:max_expiry_secs] = settings.max_expiry unless settings.max_expiry.nil?
+
+            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

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

@@ -0,0 +1,132 @@
+#  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/generated/admin/query/v1/query_pb"
+require "couchbase/protostellar/request"
+
+module Couchbase
+  module Protostellar
+    module RequestGenerator
+      module Admin
+        class Query
+          def initialize(bucket_name: nil, scope_name: nil, collection_name: nil)
+            @bucket_name = bucket_name
+            @scope_name = scope_name
+            @collection_name = collection_name
+          end
+
+          def get_all_indexes_request(options, bucket_name = nil)
+            proto_req = Generated::Admin::Query::V1::GetAllIndexesRequest.new(
+              **location(
+                bucket_name: bucket_name, scope_name: options.scope_name, collection_name: options.collection_name,
+              ),
+            )
+
+            create_request(proto_req, :get_all_indexes, options, idempotent: true)
+          end
+
+          def create_primary_index_request(options, bucket_name = nil)
+            proto_opts = {
+              deferred: options.deferred,
+              ignore_if_exists: options.ignore_if_exists,
+            }
+            proto_opts[:name] = options.index_name unless options.index_name.nil?
+            proto_opts[:num_replicas] = options.num_replicas unless options.num_replicas.nil?
+
+            proto_req = Generated::Admin::Query::V1::CreatePrimaryIndexRequest.new(
+              **location(
+                bucket_name: bucket_name, scope_name: options.scope_name, collection_name: options.collection_name,
+              ),
+              **proto_opts,
+            )
+
+            create_request(proto_req, :create_primary_index, options)
+          end
+
+          def create_index_request(index_name, fields, options, bucket_name = nil)
+            proto_opts = {
+              deferred: options.deferred,
+              ignore_if_exists: options.ignore_if_exists,
+            }
+            proto_opts[:num_replicas] = options.num_replicas unless options.num_replicas.nil?
+
+            proto_req = Generated::Admin::Query::V1::CreateIndexRequest.new(
+              **location(
+                bucket_name: bucket_name, scope_name: options.scope_name, collection_name: options.collection_name,
+              ),
+              name: index_name,
+              fields: fields,
+              **proto_opts,
+            )
+
+            create_request(proto_req, :create_index, options)
+          end
+
+          def drop_primary_index_request(options, bucket_name = nil)
+            proto_req = Generated::Admin::Query::V1::DropPrimaryIndexRequest.new(
+              **location(
+                bucket_name: bucket_name, scope_name: options.scope_name, collection_name: options.collection_name,
+              ),
+            )
+
+            create_request(proto_req, :drop_primary_index, options)
+          end
+
+          def drop_index_request(index_name, options, bucket_name = nil)
+            proto_req = Generated::Admin::Query::V1::DropIndexRequest.new(
+              **location(
+                bucket_name: bucket_name, scope_name: options.scope_name, collection_name: options.collection_name,
+              ),
+              name: index_name,
+            )
+
+            create_request(proto_req, :drop_index, options)
+          end
+
+          def build_deferred_indexes_request(options, bucket_name = nil)
+            proto_req = Generated::Admin::Query::V1::BuildDeferredIndexesRequest.new(
+              **location(
+                bucket_name: bucket_name, scope_name: options.scope_name, collection_name: options.collection_name,
+              ),
+            )
+
+            create_request(proto_req, :build_deferred_indexes, options)
+          end
+
+          private
+
+          def location(bucket_name: nil, scope_name: nil, collection_name: nil)
+            {
+              bucket_name: @bucket_name || bucket_name,
+              scope_name: @scope_name || scope_name,
+              collection_name: @collection_name || collection_name,
+            }.compact
+          end
+
+          def create_request(proto_request, rpc, options, idempotent: false)
+            Request.new(
+              service: :query_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.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
+
+module Couchbase
+  module Protostellar
+    module RequestGenerator
+      module Admin
+      end
+    end
+  end
+end