pg_eventstore 2.0.0 → 3.0.0

data/lib/pg_eventstore/basic_config.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class BasicConfig
+    include Extensions::OptionsExtension
+
+    attr_reader :name
+
+    # @param name [Symbol] config's name. Its value matches the appropriate key in PgEventstore.config hash
+    def initialize(name:, **)
+      super
+      @name = name
+    end
+  end
+end

data/lib/pg_eventstore/chunks/chunk.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Chunks
+    # @!visibility private
+    module Chunk
+      # @param size [Integer, nil] number of entities to retrieve. nil means all available. The number of entities in
+      #   the result in the single call is not guaranteed. You have to check whether chunk is drained using #drained? in
+      #   a subsequent call.
+      # @return [Array]
+      def take(size)
+        raise NotImplementedError
+      end
+
+      # @return [Boolean]
+      def drained?
+        raise NotImplementedError
+      end
+
+      # @return [Integer]
+      def size
+        raise NotImplementedError
+      end
+
+      # @return [Object, nil]
+      def last
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/pg_eventstore/chunks/read_api_events_index_chunk.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Chunks
+    # @!visibility private
+    class ReadApiEventsIndexChunk
+      include Chunk
+
+      # @return [Integer]
+      MAX_PARTITIONS_TO_RESOLVE_PER_CALL = 100
+
+      # @param indexes [Array<PgEventstore::EventGlobalIndex::ReadApiRepr>]
+      # @param connection [PgEventstore::Connection]
+      # @param query_strategy [PgEventstore::QueryStrategy]
+      # @param resolve_link_tos [Boolean]
+      def initialize(indexes, connection, query_strategy, resolve_link_tos)
+        @indexes = indexes
+        @connection = connection
+        @query_strategy = query_strategy
+        @resolve_link_tos = resolve_link_tos
+        @idx_direction = detect_direction(indexes[0], indexes[1])
+        @raw_events = []
+        @resolved = indexes.empty?
+      end
+
+      # @return [Array<Hash>] raw events array
+      def take(size)
+        resolve_indexes unless resolved?
+        @raw_events.slice!(0...size)
+      end
+
+      # @return [Boolean]
+      def drained?
+        @indexes.empty? && @raw_events.empty?
+      end
+
+      # @return [Integer]
+      def size
+        @indexes.size + @raw_events.size
+      end
+
+      # @return [PgEventstore::EventGlobalIndex::ReadApiRepr, nil]
+      def last
+        @indexes.last
+      end
+
+      private
+
+      # @param idx1 [PgEventstore::EventGlobalIndex::ReadApiRepr, nil]
+      # @param idx2 [PgEventstore::EventGlobalIndex::ReadApiRepr, nil]
+      # @return [Symbol]
+      def detect_direction(idx1, idx2)
+        return :asc if idx1.nil? || idx2.nil?
+
+        idx1.global_position > idx2.global_position ? :desc : :asc
+      end
+
+      # @return [Boolean]
+      def resolved?
+        @resolved
+      end
+
+      # @return [void]
+      def resolve_indexes
+        indexes_to_resolve = @indexes.slice!(
+          Utils.range_to_slice(@indexes.map(&:event_type_partition_id), MAX_PARTITIONS_TO_RESOLVE_PER_CALL)
+        )
+        raw_events = events_global_index_queries.resolve_indexes(
+          indexes_to_resolve,
+          direction: @idx_direction,
+          resolve_link_tos: @resolve_link_tos
+        )
+        @raw_events.push(*raw_events)
+        @resolved = @indexes.empty?
+      end
+
+      # @return [PgEventstore::EventsGlobalIndexQueries]
+      def events_global_index_queries
+        EventsGlobalIndexQueries.new(@connection, @query_strategy)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/chunks/replica_events_index_chunk.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Chunks
+    # @!visibility private
+    class ReplicaEventsIndexChunk
+      include Chunk
+
+      # @param indexes [Array<PgEventstore::EventGlobalIndex::SubscriptionRepr>]
+      def initialize(indexes)
+        @indexes = indexes
+      end
+
+      # @return [Array<RawEventWithSubscriptionPosition>] raw events array
+      def take(size)
+        @indexes.slice!(0...size)
+      end
+
+      # @return [Boolean]
+      def drained?
+        @indexes.empty?
+      end
+
+      # @return [Integer]
+      def size
+        @indexes.size
+      end
+
+      # @return [PgEventstore::EventGlobalIndex::SubscriptionRepr, nil]
+      def last
+        @indexes.last
+      end
+    end
+  end
+end

data/lib/pg_eventstore/chunks/repository.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Chunks
+    # @!visibility private
+    class Repository
+      include MonitorMixin
+
+      def initialize(...)
+        super
+        @chunks = SynchronizedArray.new
+      end
+
+      # @param chunk [PgEventstore::Chunks::Chunk]
+      # @param condition [MonitorMixin::ConditionVariable, nil]
+      # @return [void]
+      def add_chunk(chunk, condition: nil)
+        mon_try_enter
+        @chunks.push(chunk)
+        condition&.broadcast if mon_owned?
+      ensure
+        mon_exit if mon_owned?
+      end
+
+      # @return [void]
+      def clear
+        @chunks.clear
+      end
+
+      # @return [Integer]
+      def size
+        @chunks.sum(&:size)
+      end
+
+      # @return [Boolean]
+      def empty?
+        @chunks.empty?
+      end
+
+      # Consumes all chunks and returns enumerator holding them.
+      # @return [Enumerator]
+      def consume_all
+        synchronize do
+          chunks = @chunks.slice!(0..)
+          Enumerator.new do |y|
+            chunks.each do |chunk|
+              loop do
+                chunk.take(nil).each(&y.method(:<<))
+                break if chunk.drained?
+              end
+            end
+          end
+        end
+      end
+
+      # @param entities_num [Integer, nil]
+      # @param timeout [Float, Integer]
+      # @param condition [MonitorMixin::ConditionVariable]
+      # @return [Array<Object>]
+      def wait_and_consume(entities_num:, timeout:, condition:)
+        synchronize do
+          condition.wait(timeout) if @chunks.empty?
+          return [] if @chunks.empty?
+
+          chunk = @chunks.at(0)
+          chunk.take(entities_num).tap do
+            @chunks.delete(chunk) if chunk.drained?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/chunks/subscription_checkpoint_chunk.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Chunks
+    # @!visibility private
+    class SubscriptionCheckpointChunk
+      include Chunk
+
+      class Checkpoint
+        include Extensions::OptionsExtension
+        include Extensions::OptionsDefaults
+
+        # @!attribute subscription_position
+        #   @return [Integer]
+        attribute(:subscription_position)
+      end
+
+      # @param position [Integer]
+      def initialize(position)
+        @checkpoint_event = Checkpoint.new(subscription_position: position)
+      end
+
+      def take(_size)
+        if @checkpoint_event
+          event = @checkpoint_event
+          @checkpoint_event = nil
+          return [event]
+        end
+        []
+      end
+
+      # @return [Boolean]
+      def drained?
+        @checkpoint_event.nil?
+      end
+
+      # @return [Integer]
+      def size
+        @checkpoint_event ? 1 : 0
+      end
+
+      # @return [Object, nil]
+      def last
+        @checkpoint_event
+      end
+    end
+  end
+end

data/lib/pg_eventstore/chunks/subscription_events_index_chunk.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Chunks
+    # @!visibility private
+    class SubscriptionEventsIndexChunk
+      include Chunk
+
+      class RawEventWithSubscriptionPosition
+        include Extensions::OptionsExtension
+        include Extensions::OptionsDefaults
+
+        # @!attribute subscription_position
+        #   @return [Integer]
+        attribute(:subscription_position)
+        # @!attribute attributes
+        #   @return [Hash<String, Object>]
+        attribute(:attributes)
+      end
+
+      # @return [Integer]
+      MAX_PARTITIONS_TO_RESOLVE_PER_CALL = 100
+
+      # @param indexes [Array<PgEventstore::EventGlobalIndex::SubscriptionRepr>]
+      # @param connection [PgEventstore::Connection]
+      # @param query_strategy [PgEventstore::QueryStrategy]
+      # @param resolve_link_tos [Boolean]
+      def initialize(indexes, connection, query_strategy, resolve_link_tos)
+        @indexes = indexes
+        @connection = connection
+        @query_strategy = query_strategy
+        @resolve_link_tos = resolve_link_tos
+        @raw_events = []
+        @resolved = indexes.empty?
+      end
+
+      # @return [Array<RawEventWithSubscriptionPosition>] raw events array
+      def take(size)
+        resolve_indexes unless resolved?
+        @raw_events.slice!(0...size)
+      end
+
+      # @return [Boolean]
+      def drained?
+        @indexes.empty? && @raw_events.empty?
+      end
+
+      # @return [Integer]
+      def size
+        @indexes.size + @raw_events.size
+      end
+
+      # @return [PgEventstore::EventGlobalIndex::SubscriptionRepr, nil]
+      def last
+        @indexes.last
+      end
+
+      private
+
+      # @return [Boolean]
+      def resolved?
+        @resolved
+      end
+
+      # @return [void]
+      def resolve_indexes
+        indexes_to_resolve = @indexes.slice!(
+          Utils.range_to_slice(@indexes.map(&:event_type_partition_id), MAX_PARTITIONS_TO_RESOLVE_PER_CALL)
+        )
+        global_to_sub_position_map = indexes_to_resolve.to_h { [_1.global_position, _1.subscription_position] }
+        raw_events = events_global_index_queries.resolve_indexes(
+          indexes_to_resolve,
+          resolve_link_tos: @resolve_link_tos
+        )
+        raw_events = raw_events.map do |attrs|
+          global_position = attrs['link'] ? attrs['link']['global_position'] : attrs['global_position']
+          RawEventWithSubscriptionPosition.new(
+            attributes: attrs,
+            subscription_position: global_to_sub_position_map[global_position]
+          )
+        end
+        raw_events = raw_events.sort_by(&:subscription_position)
+        @raw_events.push(*raw_events)
+        @resolved = @indexes.empty?
+      rescue => exception
+        @indexes.unshift(*indexes_to_resolve)
+        @resolved = false
+        raise Utils.wrap_exception(
+          exception, global_positions: indexes_to_resolve.map(&:global_position)
+        )
+      end
+
+      # @return [PgEventstore::EventsGlobalIndexQueries]
+      def events_global_index_queries
+        EventsGlobalIndexQueries.new(@connection, @query_strategy)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/chunks.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  module Chunks
+  end
+end
+
+require_relative 'chunks/chunk'
+require_relative 'chunks/read_api_events_index_chunk'
+require_relative 'chunks/subscription_events_index_chunk'
+require_relative 'chunks/subscription_checkpoint_chunk'
+require_relative 'chunks/replica_events_index_chunk'
+require_relative 'chunks/repository'