couchbase 3.0.0.alpha.5-x86_64-linux → 3.5.1-x86_64-linux

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

@@ -0,0 +1,59 @@
+#  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"
+
+module Couchbase
+  module Protostellar
+    module ResponseConverter
+      module Admin
+        class Query
+          INDEX_TYPE_MAP = {
+            :INDEX_TYPE_VIEW => :view,
+            :INDEX_TYPE_GSI => :gsi,
+          }.freeze
+
+          INDEX_STATE_MAP = {
+            :INDEX_STATE_DEFERRED => :deferred,
+            :INDEX_STATE_BUILDING => :building,
+            :INDEX_STATE_PENDING => :pending,
+            :INDEX_STATE_ONLINE => :online,
+            :INDEX_STATE_OFFLINE => :offline,
+            :INDEX_STATE_ABRIDGED => :abridged,
+            :INDEX_STATE_SCHEDULED => :scheduled,
+          }.freeze
+
+          def self.to_query_index_array(resp)
+            resp.indexes.map do |proto_idx|
+              Couchbase::Management::QueryIndex.new do |idx|
+                idx.bucket = proto_idx.bucket_name
+                idx.scope = proto_idx.scope_name
+                idx.collection = proto_idx.collection_name
+                idx.name = proto_idx.name
+                idx.is_primary = proto_idx.is_primary
+                idx.type = INDEX_TYPE_MAP[proto_idx.type]
+                idx.state = INDEX_STATE_MAP[proto_idx.state]
+                idx.index_key = proto_idx.fields.to_a
+                idx.condition = proto_idx.condition if proto_idx.has_condition?
+                idx.partition = proto_idx.partition if proto_idx.has_partition?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/response_converter/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 ResponseConverter
+      module Admin
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/response_converter/kv.rb

@@ -0,0 +1,151 @@
+#  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/collection_options"
+require "couchbase/binary_collection_options"
+
+module Couchbase
+  module Protostellar
+    module ResponseConverter
+      class KV
+        def self.to_get_result(resp, options)
+          Couchbase::Collection::GetResult.new do |res|
+            res.transcoder = options.transcoder
+            res.cas = resp.cas
+            res.expiry = extract_expiry_time(resp) if options.respond_to?(:with_expiry) && options.with_expiry
+            res.encoded = if resp.content_uncompressed == "null" && !options.projections.empty?
+                            "{}"
+                          else
+                            resp.content_uncompressed
+                          end
+            res.flags = resp.content_flags
+          end
+        end
+
+        def self.to_mutation_result(resp)
+          Couchbase::Collection::MutationResult.new do |res|
+            res.cas = resp.cas
+            res.mutation_token = extract_mutation_token(resp)
+          end
+        end
+
+        def self.to_exists_result(resp)
+          Couchbase::Collection::ExistsResult.new do |res|
+            res.cas = resp.cas
+            res.exists = resp.result
+          end
+        end
+
+        def self.to_lookup_in_result(resp, specs, options, request)
+          Couchbase::Collection::LookupInResult.new do |res|
+            res.cas = resp.cas
+            res.transcoder = options.transcoder
+            res.encoded = resp.specs.each_with_index.map do |s, idx|
+              Couchbase::Collection::SubDocumentField.new do |f|
+                # TODO: What to do with the status?
+                error = s.status.nil? ? nil : ErrorHandling.convert_rpc_status(s.status, request)
+                f.error = error unless error.nil?
+                f.index = idx
+                f.path = specs[idx].path
+                if specs[idx].type == :exists
+                  f.exists = s.content == "true"
+                  f.value = s.content
+                elsif s.content.empty?
+                  f.value = nil
+                  f.exists = false
+                else
+                  f.value = s.content
+                  f.exists = true
+                end
+              end
+            end
+          end
+        end
+
+        def self.to_get_any_replica_result(resps, options)
+          begin
+            entry = resps.next
+          rescue StopIteration
+            raise Couchbase::Error::DocumentIrretrievable, "unable to get replica of the document"
+          end
+          Couchbase::Collection::GetReplicaResult.new do |res|
+            res.transcoder = options.transcoder
+            res.cas = entry.cas
+            res.flags = entry.content_flags
+            res.encoded = entry.content
+            res.is_replica = entry.is_replica
+          end
+        end
+
+        def self.to_get_all_replicas_result(resps, options)
+          resps.map do |entry|
+            Couchbase::Collection::GetReplicaResult.new do |res|
+              res.transcoder = options.transcoder
+              res.cas = entry.cas
+              res.flags = entry.content_flags
+              res.encoded = entry.content
+              res.is_replica = entry.is_replica
+            end
+          end
+        end
+
+        def self.to_mutate_in_result(resp, specs, options)
+          Couchbase::Collection::MutateInResult.new do |res|
+            res.cas = resp.cas
+            res.transcoder = options.transcoder
+            res.deleted = nil # TODO: gRPC response has no deleted field
+            res.mutation_token = extract_mutation_token(resp)
+            res.encoded = resp.specs.each_with_index.map do |s, idx|
+              Couchbase::Collection::SubDocumentField.new do |f|
+                f.index = idx
+                f.path = specs[idx].path
+                f.value = s.content
+              end
+            end
+          end
+        end
+
+        def self.to_counter_result(resp)
+          Couchbase::BinaryCollection::CounterResult.new do |res|
+            res.cas = resp.cas
+            res.content = resp.content
+            res.mutation_token = extract_mutation_token(resp)
+          end
+        end
+
+        def self.extract_mutation_token(resp)
+          proto_token = resp.mutation_token
+          return nil if proto_token.nil?
+
+          Couchbase::MutationToken.new do |token|
+            token.bucket_name = proto_token.bucket_name
+            token.partition_id = proto_token.vbucket_id
+            token.partition_uuid = proto_token.vbucket_uuid
+            token.sequence_number = proto_token.seq_no
+          end
+        end
+
+        def self.extract_expiry_time(resp)
+          timestamp = resp.expiry
+
+          return nil if timestamp.nil?
+
+          Time.at(timestamp.seconds, timestamp.nanos, :nsec)
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/response_converter/query.rb

@@ -0,0 +1,84 @@
+#  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 "json"
+
+require "couchbase/query_options"
+
+module Couchbase
+  module Protostellar
+    module ResponseConverter
+      class Query
+        STATUS_MAP = {
+          :STATUS_RUNNING => :running,
+          :STATUS_SUCCESS => :success,
+          :STATUS_ERRORS => :errors,
+          :STATUS_COMPLETED => :completed,
+          :STATUS_STOPPED => :stopped,
+          :STATUS_TIMEOUT => :timeout,
+          :STATUS_CLOSED => :closed,
+          :STATUS_FATAL => :fatal,
+          :STATUS_ABORTED => :aborted,
+          :STATUS_UNKNOWN => :unknown,
+        }.freeze
+
+        def self.to_query_result(resps)
+          Couchbase::Cluster::QueryResult.new do |res|
+            rows = []
+            resps.each do |resp|
+              rows.push(*resp.rows)
+              res.meta_data = convert_query_metadata(resp.meta_data) unless resp.meta_data.nil?
+            end
+            res.instance_variable_set(:@rows, rows)
+          end
+        end
+
+        def self.convert_query_metadata(proto_metadata)
+          Couchbase::Cluster::QueryMetaData.new do |meta|
+            meta.status = STATUS_MAP[proto_metadata.status]
+            meta.request_id = proto_metadata.request_id
+            meta.client_context_id = proto_metadata.client_context_id
+            meta.signature = JSON.parse(proto_metadata.signature) unless proto_metadata.signature.nil? || proto_metadata.signature.empty?
+            meta.profile = JSON.parse(proto_metadata.profile) unless proto_metadata.profile.nil? || proto_metadata.profile.empty?
+            meta.metrics = if proto_metadata.has_metrics?
+                             convert_query_metrics(proto_metadata.metrics)
+                           else
+                             Couchbase::Cluster::QueryMetrics.new
+                           end
+            meta.warnings = proto_metadata.warnings.map { |w| convert_query_warning(w) } unless proto_metadata.warnings.empty?
+          end
+        end
+
+        def self.convert_query_warning(proto_warning)
+          Couchbase::Cluster::QueryWarning.new(proto_warning.code, proto_warning.message)
+        end
+
+        def self.convert_query_metrics(proto_metrics)
+          Couchbase::Cluster::QueryMetrics.new do |metrics|
+            metrics.elapsed_time = proto_metrics.elapsed_time.nanos + (proto_metrics.elapsed_time.seconds * (10**9))
+            metrics.execution_time = proto_metrics.execution_time.nanos + (proto_metrics.execution_time.seconds * (10**9))
+            metrics.result_count = proto_metrics.result_count
+            metrics.result_size = proto_metrics.result_size
+            metrics.mutation_count = proto_metrics.mutation_count
+            metrics.sort_count = proto_metrics.sort_count
+            metrics.error_count = proto_metrics.error_count
+            metrics.warning_count = proto_metrics.warning_count
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/response_converter/search.rb

@@ -0,0 +1,136 @@
+#  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/search_options"
+
+module Couchbase
+  module Protostellar
+    module ResponseConverter
+      class Search
+        def self.to_search_result(resps, options)
+          Couchbase::Cluster::SearchResult.new do |res|
+            res.rows = []
+            res.facets = {}
+            resps.each do |resp|
+              resp.hits.each do |hit|
+                res.rows.append(convert_search_row(hit, options))
+              end
+              resp.facets.each do |k, facet_res|
+                res.facets[k] = convert_facet_result(facet_res)
+              end
+              res.meta_data = convert_meta_data(resp.meta_data) if resp.has_meta_data?
+            end
+          end
+        end
+
+        def self.convert_search_row(proto_row, options)
+          Couchbase::Cluster::SearchRow.new do |r|
+            r.instance_variable_set(:@fields, (proto_row.fields.to_h.transform_values { |v| JSON.parse(v) }).to_json)
+            r.transcoder = options.transcoder
+            r.index = proto_row.index
+            r.id = proto_row.id
+            r.score = proto_row.score.to_f
+            unless proto_row.locations.empty?
+              r.locations = Couchbase::Cluster::SearchRowLocations.new(
+                proto_row.locations.map { |loc| convert_search_row_location(loc) }
+              )
+            end
+            r.fragments = convert_fragments(proto_row.fragments)
+          end
+        end
+
+        def self.convert_fragments(proto_fragments)
+          proto_fragments.to_h.transform_values { |f| f.content.to_a }
+        end
+
+        def self.convert_search_row_location(proto_location)
+          Couchbase::Cluster::SearchRowLocation.new do |loc|
+            loc.field = proto_location.field
+            loc.term = proto_location.term
+            loc.position = proto_location.position
+            loc.start_offset = proto_location.start
+            loc.end_offset = proto_location.end
+            loc.array_positions = proto_location.array_positions.to_a
+          end
+        end
+
+        def self.convert_facet_result(proto_facet_res)
+          facet_type = proto_facet_res.search_facet
+          case facet_type
+          when :term_facet
+            res = proto_facet_res.term_facet
+            Couchbase::Cluster::SearchFacetResult::TermFacetResult.new do |f|
+              f.name = res.name
+              f.field = res.field
+              f.total = res.total
+              f.missing = res.missing
+              f.other = res.other
+              f.terms = res.terms.map do |term_res|
+                Couchbase::Cluster::SearchFacetResult::TermFacetResult::TermFacet.new(term_res.name, term_res.size)
+              end
+            end
+          when :date_range_facet
+            res = proto_facet_res.date_range_facet
+            Couchbase::Cluster::SearchFacetResult::DateRangeFacetResult.new do |f|
+              f.name = res.name
+              f.field = res.field
+              f.total = res.total
+              f.missing = res.missing
+              f.other = res.other
+              f.date_ranges = res.date_ranges.map do |date_range|
+                start_time = Time.at(date_range.start.seconds).strftime("%Y-%m-%d")
+                end_time = Time.at(date_range.end.seconds).strftime("%Y-%m-%d")
+                Couchbase::Cluster::SearchFacetResult::DateRangeFacetResult::DateRangeFacet.new(
+                  date_range.name, date_range.size, start_time, end_time
+                )
+              end
+            end
+          when :numeric_range_facet
+            res = proto_facet_res.numeric_range_facet
+            Couchbase::Cluster::SearchFacetResult::NumericRangeFacetResult.new do |f|
+              f.name = res.name
+              f.field = res.field
+              f.total = res.total
+              f.missing = res.missing
+              f.other = res.other
+              f.numeric_ranges = res.numeric_ranges.map do |numeric_range|
+                Couchbase::Cluster::NumericRangeResult::NumericRangeFacetResult::NumericRangeFacet.new(
+                  numeric_range.name, numeric_range.size, numeric_range.min, numeric_range.max
+                )
+              end
+            end
+          else
+            raise ProtostellarError, "Unrecognised facet type"
+          end
+        end
+
+        def self.convert_meta_data(proto_meta_data)
+          Couchbase::Cluster::SearchMetaData.new do |meta|
+            proto_metrics = proto_meta_data.metrics
+            dur = proto_metrics.execution_time
+            meta.metrics.took = (dur.seconds * 1000) + (dur.nanos / 1000.0).round # `took` is in milliseconds
+            meta.metrics.total_rows = proto_metrics.total_rows
+            meta.metrics.max_score = proto_metrics.max_score
+            meta.metrics.success_partition_count = proto_metrics.success_partition_count
+            meta.metrics.error_partition_count = proto_metrics.error_partition_count
+
+            meta.errors = proto_meta_data.errors.to_h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/response_converter.rb

@@ -0,0 +1,26 @@
+#  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 "response_converter/kv"
+require_relative "response_converter/query"
+
+module Couchbase
+  module Protostellar
+    # @api private
+    module ResponseConverter
+    end
+  end
+end

data/lib/couchbase/protostellar/retry/action.rb

@@ -0,0 +1,38 @@
+#  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 Retry
+      # @api private
+      class Action
+        attr_reader :duration
+
+        def initialize(duration)
+          @duration = duration
+        end
+
+        def self.with_duration(duration)
+          Action.new(duration)
+        end
+
+        def self.no_retry
+          Action.new(nil)
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/retry/orchestrator.rb

@@ -0,0 +1,60 @@
+#  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_behaviour'
+require_relative 'action'
+require 'couchbase/errors'
+require 'couchbase/logger'
+
+module Couchbase
+  module Protostellar
+    module Retry
+      # @api private
+      class Orchestrator
+        def self.maybe_retry(request, reason)
+          if reason.always_retry
+            retry_duration = get_controlled_backoff(request)
+            request.add_retry_attempt(reason)
+            # TODO: Log retry
+            RequestBehaviour.retry(retry_duration)
+          else
+            retry_action = request.retry_strategy.retry_after(request, reason)
+            duration = retry_action.duration
+            if duration.nil?
+              # TODO: Log not retried
+              RequestBehaviour.fail(Couchbase::Error::RequestCanceled.new('Cannot retry request', request.error_context))
+            else
+              request.add_retry_attempt(reason)
+              # TODO: Log retry
+              RequestBehaviour.retry(duration)
+            end
+          end
+        end
+
+        def self.get_controlled_backoff(request)
+          case request.retry_attempts
+          when 0 then 1
+          when 1 then 10
+          when 2 then 50
+          when 3 then 100
+          when 4 then 500
+          else 1000
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/retry/reason.rb

@@ -0,0 +1,67 @@
+#  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 Retry
+      class Reason
+        attr_reader :allows_non_idempotent_retry
+        attr_reader :always_retry
+        attr_reader :name
+
+        def self.reason(name, allows_non_idempotent_retry:, always_retry:)
+          const_set(
+            name,
+            new(name: name,
+                allows_non_idempotent_retry: allows_non_idempotent_retry,
+                always_retry: always_retry).freeze
+          )
+        end
+
+        def initialize(name:, allows_non_idempotent_retry:, always_retry:)
+          @name = name
+          @allows_non_idempotent_retry = allows_non_idempotent_retry
+          @always_retry = always_retry
+        end
+
+        def to_s
+          @name.downcase.to_s
+        end
+
+        reason :UNKNOWN, allows_non_idempotent_retry: false, always_retry: false
+        reason :SOCKET_NOT_AVAILABLE, allows_non_idempotent_retry: true, always_retry: false
+        reason :SERVICE_NOT_AVAILABLE, allows_non_idempotent_retry: true, always_retry: false
+        reason :NODE_NOT_AVAILABLE, allows_non_idempotent_retry: true, always_retry: false
+        reason :KV_NOT_MY_VBUCKET, allows_non_idempotent_retry: true, always_retry: true
+        reason :KV_COLLECTION_OUTDATED, allows_non_idempotent_retry: true, always_retry: true
+        reason :KV_ERROR_MAP_RETRY_INDICATED, allows_non_idempotent_retry: true, always_retry: false
+        reason :KV_LOCKED, allows_non_idempotent_retry: true, always_retry: false
+        reason :KV_TEMPORARY_FAILURE, allows_non_idempotent_retry: true, always_retry: false
+        reason :KV_SYNC_WRITE_IN_PROGRESS, allows_non_idempotent_retry: true, always_retry: false
+        reason :KV_SYNC_WRITE_RE_COMMIT_IN_PROGRESS, allows_non_idempotent_retry: true, always_retry: false
+        reason :SERVICE_RESPONSE_CODE_INDICATED, allows_non_idempotent_retry: true, always_retry: false
+        reason :SOCKET_CLOSED_WHILE_IN_FLIGHT, allows_non_idempotent_retry: false, always_retry: false
+        reason :CIRCUIT_BREAKER_OPEN, allows_non_idempotent_retry: true, always_retry: false
+        reason :QUERY_PREPARED_STATEMENT_FAILURE, allows_non_idempotent_retry: true, always_retry: false
+        reason :QUERY_INDEX_NOT_FOUND, allows_non_idempotent_retry: true, always_retry: false
+        reason :ANALYTICS_TEMPORARY_FAILURE, allows_non_idempotent_retry: true, always_retry: false
+        reason :SEARCH_TOO_MANY_REQUESTS, allows_non_idempotent_retry: true, always_retry: false
+        reason :VIEWS_TEMPORARY_FAILURE, allows_non_idempotent_retry: true, always_retry: false
+        reason :VIEWS_NO_ACTIVE_PARTITION, allows_non_idempotent_retry: true, always_retry: true
+      end
+    end
+  end
+end