event_store_client 1.4.9 → 2.0.1

data/lib/event_store_client/adapters/grpc/commands/streams/read.rb

@@ -1,103 +1,38 @@
 # frozen_string_literal: true
 
-require 'grpc'
-require 'event_store_client/adapters/grpc/generated/streams_pb.rb'
-require 'event_store_client/adapters/grpc/generated/streams_services_pb.rb'
-
-require 'event_store_client/configuration'
-require 'event_store_client/adapters/grpc/commands/command'
+require 'event_store_client/adapters/grpc/generated/streams_pb'
+require 'event_store_client/adapters/grpc/generated/streams_services_pb'
 
 module EventStoreClient
   module GRPC
     module Commands
       module Streams
         class Read < Command
-          include Configuration
-
           use_request EventStore::Client::Streams::ReadReq
           use_service EventStore::Client::Streams::Streams::Stub
 
-          StreamNotFound = Class.new(StandardError)
-
-          def call(name, options: {})
-            direction =
-              EventStoreClient::ReadDirection.new(options[:direction] || 'forwards').to_sym
-            opts = {
-              stream: {
-                stream_identifier: {
-                  streamName: name
-                }
-              },
-              read_direction: direction,
-              resolve_links: options[:resolve_links] || true,
-              count: options[:count] || config.per_page,
-              uuid_option: {
-                string: {}
-              },
-              no_filter: {}
-            }
-            options[:start] ||= 0
-            if options[:start].zero?
-              opts[:stream][:start] = {}
-            else
-              opts[:stream][:revision] = options[:start]
-            end
-
-            skip_decryption = options[:skip_decryption] || false
-            events =
-              if options[:skip_deserialization]
-                read_stream_raw(opts)
-              else
-                read_stream(opts, skip_decryption)
-              end
-            Success(events)
-          rescue StreamNotFound
-            Failure(:not_found)
+          # @api private
+          # @see {EventStoreClient::GRPC::Client#read}
+          def call(stream_name, options:, skip_deserialization:, skip_decryption:)
+            options = normalize_options(stream_name, options)
+            yield options if block_given?
+            result =
+              retry_request { service.read(request.new(options: options), metadata: metadata).to_a }
+            EventStoreClient::GRPC::Shared::Streams::ProcessResponses.new.call(
+              result,
+              skip_deserialization,
+              skip_decryption
+            )
           end
 
           private
 
-          def read_stream(options, skip_decryption)
-            retries ||= 0
-            service.read(request.new(options: options), metadata: metadata).map do |res|
-              raise StreamNotFound if res.stream_not_found
-              deserialize_event(res.event.event, skip_decryption: skip_decryption)
-            end
-          rescue ::GRPC::Unavailable
-            sleep config.grpc_unavailable_retry_sleep
-            retry if (retries += 1) <= config.grpc_unavailable_retry_count
-            raise GRPCUnavailableRetryFailed
-          end
-
-          def read_stream_raw(options)
-            retries ||= 0
-            service.read(request.new(options: options), metadata: metadata).map do |res|
-              raise StreamNotFound if res.stream_not_found
-              res.event.event
-            end
-          rescue ::GRPC::Unavailable
-            sleep config.grpc_unavailable_retry_sleep
-            retry if (retries += 1) <= config.grpc_unavailable_retry_count
-            raise GRPCUnavailableRetryFailed
-          end
-
-          def deserialize_event(entry, skip_decryption: false)
-            data = (entry.data.nil? || entry.data.empty?) ? '{}' : entry.data
-
-            metadata =
-              JSON.parse(entry.custom_metadata || '{}').merge(
-                entry.metadata.to_h || {}
-              ).to_json
-
-            event = EventStoreClient::Event.new(
-              id: entry.id.string,
-              title: "#{entry.stream_revision}@#{entry.stream_identifier.streamName}",
-              type: entry.metadata['type'],
-              data: data,
-              metadata: metadata
-            )
-
-            config.mapper.deserialize(event, skip_decryption: skip_decryption)
+          # @param stream_name [String]
+          # @param options [Hash]
+          # @return [EventStore::Client::Streams::ReadReq::Options]
+          def normalize_options(stream_name, options)
+            options = Options::Streams::ReadOptions.new(stream_name, options).request_options
+            EventStore::Client::Streams::ReadReq::Options.new(options)
           end
         end
       end

data/lib/event_store_client/adapters/grpc/commands/streams/read_paginated.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# rubocop:disable all
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module Streams
+        class ReadPaginated < Command
+          RecordsLimitError = Class.new(StandardError)
+          DEFAULT_READ_DIRECTION = :Forwards
+
+          # @api private
+          # @see {EventStoreClient::GRPC::Client#read_paginated}
+          def call(stream_name, options:, skip_deserialization:, skip_decryption:, &blk)
+            # TODO: Improve the implementation by extracting the pagination into a separate class to
+            # allow persisting the pagination options(position, direction, max_count) among the
+            # whole instance. This approach will allow us to get rid of passing paginate options
+            # into private methods explicitly.
+            position, direction, max_count = nil
+            first_call = true
+            Enumerator.new do |yielder|
+              loop do
+                response =
+                  Read.new(**connection_options).call(
+                    stream_name,
+                    options: options,
+                    skip_deserialization: true,
+                    skip_decryption: true
+                  ) do |opts|
+                    if first_call
+                      # Evaluate user-provided block only once
+                      yield opts if blk
+                      position = get_position(opts)
+                      direction = get_direction(opts)
+                      max_count = opts.count.to_i
+                      validate_max_count(max_count)
+                      first_call = false
+                    end
+
+                    paginate_options(opts, position)
+                  end
+                unless response.success?
+                  yielder << response
+                  raise StopIteration
+                end
+                processed_response =
+                  EventStoreClient::GRPC::Shared::Streams::ProcessResponses.new.call(
+                    response.success,
+                    skip_deserialization,
+                    skip_decryption
+                  )
+                yielder << processed_response if processed_response.success.any?
+                raise StopIteration if end_reached?(response.success, max_count)
+
+                position = calc_next_position(response.success, direction, stream_name)
+                raise StopIteration if position.negative?
+              end
+            end
+          end
+
+          private
+
+          # @param options [EventStore::Client::Streams::ReadReq::Options]
+          # @param position [Integer, nil]
+          # @return [EventStore::Client::Streams::ReadReq::Options, nil]
+          def paginate_options(options, position)
+            return unless position
+            return paginate_all_options(options, position) if options.stream.nil?
+
+            paginate_regular_options(options, position)
+          end
+
+          # @param options [EventStore::Client::Streams::ReadReq::Options]
+          # @param position [Integer]
+          # @return [EventStore::Client::Streams::ReadReq::Options]
+          def paginate_all_options(options, position)
+            options.all.position = EventStore::Client::Streams::ReadReq::Options::Position.new(
+              commit_position: position
+            )
+            options
+          end
+
+          # @param options [EventStore::Client::Streams::ReadReq::Options]
+          # @param position [Integer]
+          # @return [EventStore::Client::Streams::ReadReq::Options]
+          def paginate_regular_options(options, position)
+            options.stream.revision = position
+            options
+          end
+
+          # @param options [EventStore::Client::Streams::ReadReq::Options]
+          # @return [Symbol] :Backwards or :Forwards
+          def get_direction(options)
+            return options.read_direction if options.read_direction
+
+            DEFAULT_READ_DIRECTION
+          end
+
+          # @param options [EventStore::Client::Streams::ReadReq::Options]
+          # @return [Integer, nil]
+          def get_position(options)
+            # If start position is set to :end - then we need to wait for first response to get
+            # the value of the position
+            return if options.all&.end
+            return if options.stream&.end
+
+            # In case if user has provided a starting position value
+            return options.all&.position&.commit_position if options.all&.position&.commit_position
+            return options.stream&.revision if options.stream&.revision
+
+            0
+          end
+
+          # @param raw_events [Array<EventStore::Client::Streams::ReadResp>]
+          # @param direction [Symbol] :Backwards or :Forwards
+          # @param stream_name [String]
+          # @return [Integer]
+          def calc_next_position(raw_events, direction, stream_name)
+            events = meaningful_events(raw_events).map { |e| e.event.event }
+
+            return next_position_for_all(events, direction) if stream_name == '$all'
+
+            next_position_for_regular(events, direction)
+          end
+
+          # @param events [Array<EventStore::Client::Streams::ReadResp::ReadEvent::RecordedEvent>]
+          # @param direction [Symbol] :Backwards or :Forwards
+          # @return [Integer]
+          def next_position_for_all(events, direction)
+            return events.last.commit_position if direction == DEFAULT_READ_DIRECTION
+
+            events.first.commit_position
+          end
+
+          # @param events [Array<EventStore::Client::Streams::ReadResp::ReadEvent::RecordedEvent>]
+          # @param direction [Symbol] :Backwards or :Forwards
+          # @return [Integer]
+          def next_position_for_regular(events, direction)
+            return events.last.stream_revision + 1 if direction == DEFAULT_READ_DIRECTION
+
+            events.last.stream_revision - 1
+          end
+
+          # @param raw_events [Array<EventStore::Client::Streams::ReadResp>]
+          # @return [Array<EventStore::Client::Streams::ReadResp::ReadEvent::RecordedEvent>]
+          def meaningful_events(raw_events)
+            raw_events.select { |read_resp| read_resp.event&.event }
+          end
+
+          # @param raw_events [Array<EventStore::Client::Streams::ReadResp>]
+          # @param max_count [Integer]
+          # @return [Boolean]
+          def end_reached?(raw_events, max_count)
+            meaningful_events(raw_events).size < max_count
+          end
+
+          # @return [void]
+          # @raise [RecordsLimitError] raises error in case if max_count is less than 2
+          def validate_max_count(max_count)
+            return if max_count >= 2
+
+            raise(
+              RecordsLimitError,
+              'Pagination requires :max_count option to be greater than or equal to 2. ' \
+              "Current value is `#{max_count}'."
+            )
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable all

data/lib/event_store_client/adapters/grpc/commands/streams/subscribe.rb

@@ -1,129 +1,54 @@
 # frozen_string_literal: true
 
-require 'grpc'
-require 'event_store_client/adapters/grpc/generated/streams_pb.rb'
-require 'event_store_client/adapters/grpc/generated/streams_services_pb.rb'
-
-require 'event_store_client/configuration'
-require 'event_store_client/adapters/grpc/commands/command'
+require 'event_store_client/adapters/grpc/generated/streams_pb'
+require 'event_store_client/adapters/grpc/generated/streams_services_pb'
 
 module EventStoreClient
   module GRPC
     module Commands
       module Streams
         class Subscribe < Command
-          include Configuration
-
           use_request EventStore::Client::Streams::ReadReq
           use_service EventStore::Client::Streams::Streams::Stub
 
-          StreamNotFound = Class.new(StandardError)
+          def initialize(**conn_options)
+            # Subscriptions should never be timed out
+            super(**conn_options.merge(timeout: nil))
+          end
 
-          def call(options = {})
-            opts = options_with_defaults(options)
+          # @api private
+          # @see {EventStoreClient::GRPC::Client#read}
+          def call(stream_name, handler:, options:, skip_deserialization:, skip_decryption:)
+            options = normalize_options(stream_name, options)
+            yield options if block_given?
 
-            service.read(request.new(options: opts), metadata: metadata).map do |res|
-              raise StreamNotFound if res.stream_not_found
+            callback = proc do |response|
+              result = Shared::Streams::ProcessResponse.new.call(
+                response,
+                skip_deserialization,
+                skip_decryption
+              )
 
-              yield prepared_response(res) if block_given?
+              handler.call(result) if result
             end
-          rescue StreamNotFound
-            Failure(:not_found)
+            Success(
+              retry_request do
+                service.read(request.new(options: options), metadata: metadata, &callback)
+              end
+            )
           end
 
           private
 
-          def prepared_response(res)
-            if res.event
-              event = res.event.event
-              [position(event), deserialize_event(event)] rescue event
-            elsif res.checkpoint
-              [position(res.checkpoint), nil]
-            elsif res.confirmation
-              res.confirmation
-            end
-          end
-
-          def position(event_or_checkpoint)
-            {
-              prepare_position: event_or_checkpoint.prepare_position,
-              commit_position: event_or_checkpoint.commit_position
-            }
-          end
-
-          def read_direction(direction)
-            EventStoreClient::ReadDirection.new(direction || 'forwards').to_sym
-          end
-
-          def options_with_defaults(options)
-            options[:without_system_events] = true unless options[:without_system_events] == false
-            opts = {
-              subscription: {},
-              read_direction: read_direction(options[:direction]),
-              resolve_links: options[:resolve_links] || true,
-              uuid_option: {
-                string: {}
-              }
-            }
-            if options[:stream]
-              opts[:stream] = {
-                stream_identifier: {
-                  streamName: stream
-                }
-              }
-            else
-              opts[:all] = options[:all] || default_all_options
-            end
-            if options[:filter]
-              opts[:filter] = options[:filter]
-            elsif options[:without_system_events]
-              opts[:filter] = {
-                event_type: { regex: '^[^$].*' },
-                max: 32,
-                checkpointIntervalMultiplier: 1000
-              }
-            else
-              opts[:no_filter] = {}
-            end
-
-            options[:start] ||= 0
-
-            return opts unless options[:stream]
-
-            if options[:start].zero?
-              opts[:stream][:start] = {}
-            else
-              opts[:stream][:revision] = options[:start]
+          # @param stream_name [String]
+          # @param options [Hash]
+          # @return [EventStore::Client::Streams::ReadReq::Options]
+          def normalize_options(stream_name, options)
+            options = Options::Streams::ReadOptions.new(stream_name, options).request_options
+            EventStore::Client::Streams::ReadReq::Options.new(options).tap do |opts|
+              opts.subscription =
+                EventStore::Client::Streams::ReadReq::Options::SubscriptionOptions.new
             end
-            opts
-          end
-
-          def default_all_options
-            {
-              position: {
-                commit_position: 0,
-                prepare_position: 0
-              }
-            }
-          end
-
-          def deserialize_event(entry)
-            data = (entry.data.nil? || entry.data.empty?) ? '{}' : entry.data
-
-            metadata =
-              JSON.parse(entry.custom_metadata || '{}').merge(
-                entry.metadata.to_h || {}
-              ).to_json
-
-            event = EventStoreClient::Event.new(
-              id: entry.id.string,
-              title: "#{entry.stream_revision}@#{entry.stream_identifier.streamName}",
-              type: entry.metadata['type'],
-              data: data,
-              metadata: metadata
-            )
-
-            config.mapper.deserialize(event)
           end
         end
       end

data/lib/event_store_client/adapters/grpc/connection.rb

@@ -8,49 +8,69 @@ module EventStoreClient
   module GRPC
     class Connection
       include Configuration
+      include Extensions::OptionsExtension
 
-      class SocketErrorRetryFailed < StandardError; end
-
-      # Initializes the proper stub with the necessary credentials
-      # to create working gRPC connection - Refer to generated grpc files
-      # @return [Stub] Instance of a given `Stub` klass
-      #
-      def call(stub_klass, options: {})
-        credentials =
-          options[:credentials] ||
-          Base64.encode64("#{config.eventstore_user}:#{config.eventstore_password}")
-        stub_klass.new(
-          "#{config.eventstore_url.host}:#{config.eventstore_url.port}",
-          channel_credentials,
-          channel_args: { 'authorization' => "Basic #{credentials.delete("\n")}" }
-        )
-      end
+      option(:host) { Discover.current_member.host }
+      option(:port) { Discover.current_member.port }
+      option(:username) { config.eventstore_url.username }
+      option(:password) { config.eventstore_url.password }
+      option(:timeout) { config.eventstore_url.timeout }
 
-      private
+      class << self
+        include Configuration
+
+        # Resolve which connection class we instantiate, based on config.eventstore_url.tls config
+        # option. If :new method is called from SecureConnection or InsecureConnection class - then
+        # that particular class will be instantiated despite on config.eventstore_url.tls config
+        # option. Example:
+        #   ```ruby
+        #   config.eventstore_url.tls = true
+        #   Connection.new # => #<EventStoreClient::GRPC::Cluster::SecureConnection>
+        #
+        #   config.eventstore_url.tls = false
+        #   Connection.new # => #<EventStoreClient::GRPC::Cluster::InsecureConnection>
+        #
+        #   Cluster::SecureConnection.new
+        #   # => #<EventStoreClient::GRPC::Cluster::SecureConnection>
+        #   Cluster::InsecureConnection.new
+        #   # => #<EventStoreClient::GRPC::Cluster::InsecureConnection>
+        #   ```
+        def new(*args, **kwargs, &blk)
+          return super unless self == Connection
 
-      attr_reader :cert
-
-      def initialize
-        retries ||= 0
-        @cert =
-          Net::HTTP.start(
-            config.eventstore_url.host, config.eventstore_url.port,
-            use_ssl: true,
-            verify_mode: verify_ssl,
-            &:peer_cert
-          )
-      rescue SocketError
-        sleep config.socket_error_retry_sleep
-        retry if (retries += 1) <= config.socket_error_retry_count
-        raise SocketErrorRetryFailed
+          if config.eventstore_url.tls
+            Cluster::SecureConnection.new(*args, **kwargs, &blk)
+          else
+            Cluster::InsecureConnection.new(*args, **kwargs, &blk)
+          end
+        end
+
+        # Checks if connection class is secure
+        # @return [Boolean]
+        def secure?
+          self == Cluster::SecureConnection
+        end
       end
 
-      def channel_credentials
-        ::GRPC::Core::ChannelCredentials.new(cert.to_s)
+      def call(stub_class)
+        raise NotImplementedError
       end
 
-      def verify_ssl
-        config.verify_ssl || OpenSSL::SSL::VERIFY_NONE
+      private
+
+      # Common channel arguments for all GRPC requests.
+      # Available channel arguments are described here
+      # https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/grpc_types.h
+      # @return [Hash]
+      def channel_args
+        {
+          # disable build-in GRPC retries functional
+          'grpc.enable_retries' => 0,
+          # These three options reduce delays between failed requests.
+          'grpc.min_reconnect_backoff_ms' => 100, # milliseconds
+          'grpc.max_reconnect_backoff_ms' => 100, # milliseconds
+          'grpc.initial_reconnect_backoff_ms' => 100 # milliseconds
+        }
       end
     end
   end

data/lib/event_store_client/adapters/grpc/discover.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/CyclomaticComplexity
+
+module EventStoreClient
+  module GRPC
+    class Discover
+      include Configuration
+
+      class << self
+        # @return [EventStoreClient::GRPC::Cluster::Member]
+        def current_member
+          @exception = nil
+          return @current_member if member_alive?
+
+          semaphore.synchronize do
+            raise @exception if @exception
+            return @current_member if member_alive?
+
+            failed_member = @current_member if @current_member&.failed_endpoint
+            @current_member =
+              begin
+                new.call(failed_member: failed_member)
+              rescue StandardError => e
+                @exception = e
+                nil
+              end
+          end
+          raise @exception if @exception
+
+          @current_member
+        end
+
+        # @return [Boolean]
+        def member_alive?
+          return false if @current_member&.failed_endpoint
+
+          !@current_member.nil?
+        end
+
+        private
+
+        # @return [Thread::Mutex]
+        def semaphore
+          @semaphore ||= Thread::Mutex.new
+        end
+      end
+
+      # @param failed_member [EventStoreClient::GRPC::Cluster::Member, nil]
+      # @return [EventStoreClient::GRPC::Cluster::Member]
+      def call(failed_member: nil)
+        if needs_discover?
+          return Cluster::GossipDiscover.new.call(nodes, failed_member: failed_member)
+        end
+
+        Cluster::QuerylessDiscover.new.call(config.eventstore_url.nodes.to_a)
+      end
+
+      private
+
+      # @return [Array<EventStoreClient::Connection::Url::Node>]
+      def nodes
+        return [config.eventstore_url.nodes.first] if config.eventstore_url.dns_discover
+
+        config.eventstore_url.nodes.to_a
+      end
+
+      # @return [Boolean]
+      def needs_discover?
+        config.eventstore_url.dns_discover || config.eventstore_url.nodes.size > 1
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/CyclomaticComplexity