couchbase 3.5.3-arm64-darwin

data/lib/couchbase/protostellar/binary_collection.rb

@@ -0,0 +1,55 @@
+#  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/options"
+
+require_relative "response_converter/kv"
+
+module Couchbase
+  module Protostellar
+    class BinaryCollection
+      def initialize(collection)
+        @collection = collection
+        @client = collection.instance_variable_get(:@client)
+        @kv_request_generator = collection.instance_variable_get(:@kv_request_generator)
+      end
+
+      def append(id, content, options = Options::Append::DEFAULT)
+        req = @kv_request_generator.append_request(id, content, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_mutation_result(resp)
+      end
+
+      def prepend(id, content, options = Options::Prepend::DEFAULT)
+        req = @kv_request_generator.prepend_request(id, content, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_mutation_result(resp)
+      end
+
+      def increment(id, options = Options::Increment::DEFAULT)
+        req = @kv_request_generator.increment_request(id, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_counter_result(resp)
+      end
+
+      def decrement(id, options = Options::Decrement::DEFAULT)
+        req = @kv_request_generator.decrement_request(id, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_counter_result(resp)
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/bucket.rb

@@ -0,0 +1,55 @@
+#  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 "scope"
+require_relative "management"
+
+module Couchbase
+  module Protostellar
+    class Bucket
+      attr_reader :name
+
+      def initialize(client, name)
+        @client = client
+        @name = name
+      end
+
+      def scope(name)
+        Scope.new(@client, @name, name)
+      end
+
+      def collection(name)
+        default_scope.collection(name)
+      end
+
+      def default_scope
+        Scope.new(@client, @name, "_default")
+      end
+
+      def default_collection
+        default_scope.collection("_default")
+      end
+
+      def collections
+        Management::CollectionManager.new(client: @client, bucket_name: @name)
+      end
+
+      def ping(_options = Options::Ping::DEFAULT)
+        raise Couchbase::Error::FeatureNotAvailable, "The #{Protostellar::NAME} protocol does not support ping"
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/client.rb

@@ -0,0 +1,99 @@
+#  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 "error_handling"
+
+require_relative "generated/routing/v1/routing_services_pb"
+require_relative "generated/kv/v1/kv_services_pb"
+require_relative "generated/query/v1/query_services_pb"
+require_relative "generated/search/v1/search_services_pb"
+require_relative "generated/analytics/v1/analytics_services_pb"
+require_relative "generated/view/v1/view_services_pb"
+require_relative "generated/admin/collection/v1/collection_services_pb"
+require_relative "generated/admin/bucket/v1/bucket_services_pb"
+require_relative "generated/admin/query/v1/query_services_pb"
+require_relative "generated/admin/search/v1/search_services_pb"
+
+module Couchbase
+  module Protostellar
+    # @api private
+    class Client
+      def initialize(host:, credentials:, channel_args:, call_metadata:, timeouts:)
+        @channel = GRPC::Core::Channel.new(host, channel_args, credentials)
+        @call_metadata = call_metadata
+        @timeouts = timeouts
+
+        @stubs = {
+          routing: Generated::Routing::V1::RoutingService::Stub.new(host, credentials, channel_override: @channel),
+          kv: Generated::KV::V1::KvService::Stub.new(host, credentials, channel_override: @channel),
+          query: Generated::Query::V1::QueryService::Stub.new(host, credentials, channel_override: @channel),
+          search: Generated::Search::V1::SearchService::Stub.new(host, credentials, channel_override: @channel),
+          analytics: Generated::Analytics::V1::AnalyticsService::Stub.new(host, credentials, channel_override: @channel),
+          view: Generated::View::V1::ViewService::Stub.new(host, credentials, channel_override: @channel),
+          bucket_admin: Generated::Admin::Bucket::V1::BucketAdminService::Stub.new(host, credentials, channel_override: @channel),
+          collection_admin: Generated::Admin::Collection::V1::CollectionAdminService::Stub.new(host, credentials,
+                                                                                               channel_override: @channel),
+          query_admin: Generated::Admin::Query::V1::QueryAdminService::Stub.new(host, credentials, channel_override: @channel),
+          search_admin: Generated::Admin::Search::V1::SearchAdminService::Stub.new(host, credentials, channel_override: @channel),
+        }
+      end
+
+      def close
+        @channel.close
+      end
+
+      def send_request(request)
+        request.set_timeout_from_defaults(@timeouts)
+        loop do
+          resp = @stubs[request.service].public_send(request.rpc, request.proto_request, deadline: request.deadline,
+                                                                                         metadata: @call_metadata)
+          return resp unless resp.respond_to?(:next)
+
+          # Streaming RPC - wrap it in an enumerator that handles any mid-stream errors
+          return Enumerator.new do |y|
+            loop do
+              y << resp.next
+            rescue GRPC::BadStatus => e
+              request_behaviour = ErrorHandling.handle_grpc_error(e, request)
+              raise request_behaviour.error unless request_behaviour.error.nil?
+
+              unless request_behaviour.retry_duration.nil?
+                raise Couchbase::Error::RequestCanceled.new("Error encountered mid-stream",
+                                                            request.error_context)
+              end
+
+              next
+            end
+          end
+
+        # Simple RPC - just return it
+        rescue GRPC::BadStatus => e
+          request_behaviour = ErrorHandling.handle_grpc_error(e, request)
+
+          unless request_behaviour.error.nil? ^ request_behaviour.retry_duration.nil?
+            raise Couchbase::Error::CouchbaseError, "Either the error or the retry duration can be set"
+          end
+          raise request_behaviour.error unless request_behaviour.error.nil?
+
+          unless request_behaviour.retry_duration.nil?
+            sleep(0.001 * request_behaviour.retry_duration)
+            next
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/cluster.rb

@@ -0,0 +1,171 @@
+#  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/options"
+
+module Couchbase
+  module Protostellar
+    class Cluster
+      VALID_CONNECTION_STRING_PARAMS = [
+        "trust_certificate",
+      ].freeze
+
+      attr_reader :client
+
+      # Connect to the Couchbase cluster
+      #
+      # @overload connect(connection_string, options)
+      #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+      #   @param [Options::Cluster] options custom options when creating the cluster connection
+      #
+      # @overload connect(connection_string, username, password, options)
+      #   Shortcut for {PasswordAuthenticator}
+      #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+      #   @param [String] username name of the user
+      #   @param [String] password password of the user
+      #   @param [Options::Cluster, nil] options custom options when creating the cluster connection
+      #
+      # @overload connect(configuration, options)
+      #   @param [Configuration] configuration configuration object
+      #   @param [Options::Cluster, nil] options custom options when creating the cluster connection
+      def self.connect(connection_string_or_config, *args)
+        require_relative "connect_options"
+        require_relative "bucket"
+        require_relative "client"
+        require_relative "timeouts"
+        require_relative "management/bucket_manager"
+        require_relative "request_generator/query"
+        require_relative "request_generator/search"
+        require_relative "response_converter/query"
+        require_relative "response_converter/search"
+        require_relative "management/query_index_manager"
+
+        connection_string = nil
+        username = nil
+        password = nil
+        options = nil
+
+        if connection_string_or_config.is_a?(Couchbase::Configuration)
+          connection_string = connection_string_or_config.connection_string
+          username = connection_string_or_config.username
+          password = connection_string_or_config.password
+          options = args[0] || Couchbase::Options::Cluster.new
+        else
+          connection_string = connection_string_or_config
+          case args[0]
+          when String
+            username = args[0]
+            password = args[1]
+            options = args[2] || Couchbase::Options::Cluster.new
+          when Couchbase::Options::Cluster
+            options = args[0]
+            case options.authenticator
+            when Couchbase::PasswordAuthenticator
+              username = options.authenticator.username
+              password = options.authenticator.password
+            when Couchbase::CertificateAuthenticator
+              raise Couchbase::Error::FeatureNotAvailable,
+                    "The #{Couchbase::Protostellar::NAME} protocol does not support the CertificateAuthenticator"
+            else
+              raise ArgumentError, "options must have authenticator configured"
+            end
+          else
+            raise ArgumentError, "unexpected second argument, have to be String or Couchbase::Options::Cluster"
+          end
+        end
+
+        raise ArgumentError, "missing username" unless username
+        raise ArgumentError, "missing password" unless password
+
+        params = parse_connection_string_params(connection_string)
+        connect_options = ConnectOptions.new(
+          username: username,
+          password: password,
+          timeouts: Protostellar::Timeouts.from_cluster_options(options),
+          root_certificates: params.key?("trust_certificate") ? File.read(params["trust_certificate"]) : nil
+        )
+        new(connection_string.split("://")[1].split("?")[0], connect_options)
+      end
+
+      def self.parse_connection_string_params(connection_string)
+        params =
+          if connection_string.include?("?")
+            connection_string.split("?")[1].split("&").to_h { |p| p.split("=") }
+          else
+            {}
+          end
+
+        # Show warnings for the connection string parameters that are not supported
+        params.each do |k, v|
+          warn "Unsupported parameter '#{k}' in connection string (value '#{v}')" unless VALID_CONNECTION_STRING_PARAMS.include?(k)
+        end
+
+        params
+      end
+
+      def disconnect
+        @client.close
+      end
+
+      def bucket(name)
+        Bucket.new(@client, name)
+      end
+
+      def buckets
+        Management::BucketManager.new(@client)
+      end
+
+      def query_indexes
+        Management::QueryIndexManager.new(client: @client)
+      end
+
+      def query(statement, options = Couchbase::Options::Query::DEFAULT)
+        req = @query_request_generator.query_request(statement, options)
+        resps = @client.send_request(req)
+        ResponseConverter::Query.to_query_result(resps)
+      end
+
+      def search_query(index_name, query, options = Couchbase::Options::Search::DEFAULT)
+        req = @search_request_generator.search_query_request(index_name, query, options)
+        resp = @client.send_request(req)
+        ResponseConverter::Search.to_search_result(resp, options)
+      end
+
+      def diagnostics(_options = Options::Diagnostics::DEFAULT)
+        raise Couchbase::Error::FeatureNotAvailable, "The #{Protostellar::NAME} protocol does not support diagnostics"
+      end
+
+      def ping(_options = Options::Ping::DEFAULT)
+        raise Couchbase::Error::FeatureNotAvailable, "The #{Protostellar::NAME} protocol does not support ping"
+      end
+
+      private
+
+      def initialize(host, options = ConnectOptions.new)
+        @client = Client.new(
+          host: host.include?(":") ? host : "#{host}:18098",
+          credentials: options.grpc_credentials,
+          channel_args: options.grpc_channel_args,
+          call_metadata: options.grpc_call_metadata,
+          timeouts: options.timeouts
+        )
+
+        @query_request_generator = RequestGenerator::Query.new
+        @search_request_generator = RequestGenerator::Search.new
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/collection.rb

@@ -0,0 +1,152 @@
+#  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/options"
+require "couchbase/errors"
+require "couchbase/collection_options"
+
+require_relative "request_generator/kv"
+require_relative "response_converter/kv"
+require_relative "binary_collection"
+require_relative "management/collection_query_index_manager"
+
+require "google/protobuf/well_known_types"
+
+module Couchbase
+  module Protostellar
+    class Collection
+      attr_reader :bucket_name
+      attr_reader :scope_name
+      attr_reader :name
+
+      def initialize(client, bucket_name, scope_name, name)
+        @client = client
+        @bucket_name = bucket_name
+        @scope_name = scope_name
+        @name = name
+        @kv_request_generator = RequestGenerator::KV.new(@bucket_name, @scope_name, @name)
+      end
+
+      def binary
+        BinaryCollection.new(self)
+      end
+
+      def query_indexes
+        Management::CollectionQueryIndexManager.new(
+          client: @client,
+          bucket_name: @bucket_name,
+          scope_name: @scope_name,
+          collection_name: @name
+        )
+      end
+
+      def get(id, options = Couchbase::Options::Get::DEFAULT)
+        req = @kv_request_generator.get_request(id, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_get_result(resp, options)
+      end
+
+      def get_and_touch(id, expiry, options = Couchbase::Options::GetAndTouch::DEFAULT)
+        req = @kv_request_generator.get_and_touch_request(id, expiry, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_get_result(resp, options)
+      end
+
+      def get_and_lock(id, lock_time, options = Couchbase::Options::GetAndLock::DEFAULT)
+        req = @kv_request_generator.get_and_lock_request(id, lock_time, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_get_result(resp, options)
+      end
+
+      def unlock(id, cas, options = Couchbase::Options::Unlock::DEFAULT)
+        req = @kv_request_generator.unlock_request(id, cas, options)
+        @client.send_request(req)
+      end
+
+      def touch(id, expiry, options = Couchbase::Options::Touch::DEFAULT)
+        req = @kv_request_generator.touch_request(id, expiry, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_mutation_result(resp)
+      end
+
+      def upsert(id, content, options = Couchbase::Options::Upsert::DEFAULT)
+        req = @kv_request_generator.upsert_request(id, content, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_mutation_result(resp)
+      end
+
+      def remove(id, options = Couchbase::Options::Remove::DEFAULT)
+        req = @kv_request_generator.remove_request(id, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_mutation_result(resp)
+      end
+
+      def insert(id, content, options = Couchbase::Options::Insert::DEFAULT)
+        req = @kv_request_generator.insert_request(id, content, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_mutation_result(resp)
+      end
+
+      def replace(id, content, options = Couchbase::Options::Replace::DEFAULT)
+        req = @kv_request_generator.replace_request(id, content, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_mutation_result(resp)
+      end
+
+      def exists(id, options = Couchbase::Options::Exists::DEFAULT)
+        req = @kv_request_generator.exists_request(id, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_exists_result(resp)
+      end
+
+      def lookup_in(id, specs, options = Couchbase::Options::LookupIn::DEFAULT)
+        req = @kv_request_generator.lookup_in_request(id, specs, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_lookup_in_result(resp, specs, options, req)
+      end
+
+      def lookup_in_any_replica(_id, _specs, _options = Couchbase::Options::LookupInAnyReplica::DEFAULT)
+        raise Couchbase::Error::FeatureNotAvailable, "The #{Protostellar::NAME} protocol does not support lookup in any replica"
+      end
+
+      def lookup_in_all_replicas(_id, _specs, _options = Couchbase::Options::LookupInAllReplicas::DEFAULT)
+        raise Couchbase::Error::FeatureNotAvailable, "The #{Protostellar::NAME} protocol does not support lookup in all replicas"
+      end
+
+      def mutate_in(id, specs, options = Couchbase::Options::MutateIn::DEFAULT)
+        req = @kv_request_generator.mutate_in_request(id, specs, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_mutate_in_result(resp, specs, options)
+      end
+
+      def get_any_replica(id, options = Couchbase::Options::GetAnyReplica::DEFAULT)
+        req = @kv_request_generator.get_any_replica_request(id, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_get_any_replica_result(resp, options)
+      end
+
+      def get_all_replicas(id, options = Couchbase::Options::GetAllReplicas::DEFAULT)
+        req = @kv_request_generator.get_all_replicas_request(id, options)
+        resp = @client.send_request(req)
+        ResponseConverter::KV.to_get_all_replicas_result(resp, options)
+      end
+
+      def scan(_scan_type, _options = Options::Scan::DEFAULT)
+        raise Couchbase::Error::FeatureNotAvailable, "The #{Protostellar::NAME} protocol does not support KV scans"
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/connect_options.rb

@@ -0,0 +1,63 @@
+#  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 "base64"
+
+require_relative "timeouts"
+
+module Couchbase
+  module Protostellar
+    # @api private
+    class ConnectOptions
+      attr_reader :timeouts
+
+      def initialize(timeouts: Timeouts.new,
+                     username: nil,
+                     password: nil,
+                     root_certificates: nil,
+                     client_certificate: nil,
+                     private_key: nil)
+        @timeouts = timeouts
+        @username = username
+        @password = password
+        @root_certificates = root_certificates
+        @client_certificate = client_certificate
+        @private_key = private_key
+      end
+
+      def grpc_credentials
+        if @root_certificates
+          GRPC::Core::ChannelCredentials.new(@root_certificates, @client_certificate, @private_key)
+        else
+          # Use default certificates
+          GRPC::Core::ChannelCredentials.new(nil, @client_certificate, @private_key)
+        end
+      end
+
+      def grpc_call_metadata
+        if @username && @password
+          {"authorization" => ["Basic #{Base64.strict_encode64("#{@username}:#{@password}")}"]}
+        else
+          {}
+        end
+      end
+
+      def grpc_channel_args
+        {}
+      end
+    end
+  end
+end