pg_eventstore 1.12.0 → 1.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0de14f58d080bcab32005e045530ca7888761e5415d013dbb262746a02806ba
-  data.tar.gz: fee7b7335212796361b5ded87497c7d744ed5ddfd011a47d54cc2b545991b227
+  metadata.gz: b8ddfb0310abc9f9b78b20c0f8c6466ad2ae585ce66fd7ecae7a94bd6fe179a6
+  data.tar.gz: 2e06fa6f70db70b61f867d33a02eb8c13b50937f6c5afc7cf29f670f8759a9af
 SHA512:
-  metadata.gz: 0dbdd04e5778b292177062e5a44ed9ee4c2fc03e98da945a73523036f62ed09cc27ac00d1a5853e99975b82fc798f2f83639bbb2cd4f1745150ff121ca5d7056
-  data.tar.gz: 060f8b1b51cda7be2c472f914dc611fee2db052a2cd773676013b2175e58cf12c3895e8b631a0d79443804f3a733ca25d7012fac6519551308c890df065457d5
+  metadata.gz: f31f6c07073da1a1f460cf65ec55056e1bc7ab28c72f69361cf2c77219ea529324eba85aebbd94cffecbcf3d0354c73b43ca9c3441a7dae39fbc91df8bce792f
+  data.tar.gz: 8b60ce11b14e5832d53f732690043c55662d5007a919d7a734199a55b4f07be7f1faa1ee13163dda12cac4e7772d6f7a12d57966a07ea021dd00b6cfee80a549

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [1.13.1]
+
+- Do not modify public methods arguments
+
+## [1.13.0]
+
+- Introduce automatic subscriptions recovery from connection errors. This way if a subscription process loses the connection to the database - it will be trying to reconnect until the connection is restored.
+- Resolve ambiguity in usage of `PgEventstore.config` method. It now returns the frozen object.
+
 ## [1.12.0]
 
 - Introduce `#read_grouped` API method that allows to group events by type

data/lib/pg_eventstore/cli/commands/base_command.rb

@@ -3,7 +3,9 @@
 module PgEventstore
   module CLI
     module Commands
+      # @!visibility private
       class BaseCommand
+        # @!visibility private
         module BaseCommandActions
           # @return [Integer] exit code
           def call

data/lib/pg_eventstore/cli/commands/callback_handlers/start_cmd_handlers.rb

@@ -4,6 +4,7 @@ module PgEventstore
   module CLI
     module Commands
       module CallbackHandlers
+        # @!visibility private
         class StartCmdHandlers
           include Extensions::CallbackHandlersExtension
 

data/lib/pg_eventstore/cli/commands/help_command.rb

@@ -3,6 +3,7 @@
 module PgEventstore
   module CLI
     module Commands
+      # @!visibility private
       class HelpCommand
         attr_reader :options
 

data/lib/pg_eventstore/cli/commands/start_subscriptions_command.rb

@@ -5,6 +5,7 @@ require_relative 'callback_handlers/start_cmd_handlers'
 module PgEventstore
   module CLI
     module Commands
+      # @!visibility private
       class StartSubscriptionsCommand < BaseCommand
         # @return [Integer] seconds
         KEEP_ALIVE_INTERVAL = 2
@@ -55,8 +56,9 @@ module PgEventstore
                 manager.stop
               end
             end.each(&:join)
-            Utils.remove_file(options.pid_path)
+          ensure
             @running = false
+            Utils.remove_file(options.pid_path)
           end
         end
 

data/lib/pg_eventstore/cli/commands/stop_subscriptions_command.rb

@@ -3,6 +3,7 @@
 module PgEventstore
   module CLI
     module Commands
+      # @!visibility private
       class StopSubscriptionsCommand < BaseCommand
         # @return [Integer] exit code
         def call

data/lib/pg_eventstore/cli/exit_codes.rb

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module CLI
+    # @!visibility private
     module ExitCodes
       # @return [Integer]
       SUCCESS = 0

data/lib/pg_eventstore/cli/parser_options/base_options.rb

@@ -3,6 +3,7 @@
 module PgEventstore
   module CLI
     module ParserOptions
+      # @!visibility private
       class BaseOptions
         include Extensions::OptionsExtension
 

data/lib/pg_eventstore/cli/parser_options/default_options.rb

@@ -3,6 +3,7 @@
 module PgEventstore
   module CLI
     module ParserOptions
+      # @!visibility private
       class DefaultOptions < BaseOptions
       end
     end

data/lib/pg_eventstore/cli/parser_options/metadata.rb

@@ -3,6 +3,7 @@
 module PgEventstore
   module CLI
     module ParserOptions
+      # @!visibility private
       class Metadata
         include Extensions::OptionsExtension
 

data/lib/pg_eventstore/cli/parser_options/subscription_options.rb

@@ -3,6 +3,7 @@
 module PgEventstore
   module CLI
     module ParserOptions
+      # @!visibility private
       class SubscriptionOptions < BaseOptions
         option(
           :pid_path,

data/lib/pg_eventstore/cli/try_to_delete_subscriptions_set.rb

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module CLI
+    # @!visibility private
     class TryToDeleteSubscriptionsSet
       class << self
         def try_to_delete(...)
@@ -30,7 +31,7 @@ module PgEventstore
         # Potentially CommandsHandler can be dead exactly at the same moment we expect it to process "Ping" command.
         # Wait for potential recover plus run interval and plus another second to allow potential processing of
         # "Ping" command. "Ping" command comes in prio, so it is guaranteed it will be processed as a first command.
-        sleep CommandsHandler::RESTART_DELAY + CommandsHandler::PULL_INTERVAL + 1
+        sleep RunnerRecoveryStrategies::RestoreConnection::TIME_BETWEEN_RETRIES + CommandsHandler::PULL_INTERVAL + 1
         if subscriptions_set_commands_queries.find_by(subscriptions_set_id: subscriptions_set_id, command_name: cmd_name)
           # "Ping" command wasn't consumed. Related process must be dead.
           subscriptions_set_queries.delete(subscriptions_set_id)

data/lib/pg_eventstore/cli/try_unlock_subscriptions_set.rb

@@ -5,6 +5,7 @@ require_relative 'wait_for_subscriptions_set_shutdown'
 
 module PgEventstore
   module CLI
+    # @!visibility private
     class TryUnlockSubscriptionsSet
       class << self
         def try_unlock(...)

data/lib/pg_eventstore/cli/wait_for_subscriptions_set_shutdown.rb

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module CLI
+    # @!visibility private
     class WaitForSubscriptionsSetShutdown
       class << self
         def wait_for_shutdown(...)

data/lib/pg_eventstore/connection.rb

@@ -67,9 +67,9 @@ module PgEventstore
       should_retry = true
       @pool.with do |conn|
         yield conn
-      rescue PG::ConnectionBad
-        # Recover connection after fork. We do it only once and without any delay. Recover is required by both
-        # processes - child process and parent process
+      rescue PG::ConnectionBad, PG::UnableToSend
+        # Recover a connection after fork or when we lost a connection to PostgreSQL. We retry only once and without any
+        # delay.
         conn.sync_reset
         raise unless should_retry
         should_retry = false
@@ -77,6 +77,11 @@ module PgEventstore
       end
     end
 
+    # @return [void]
+    def shutdown
+      @pool.shutdown(&:close)
+    end
+
     private
 
     # @return [ConnectionPool]

data/lib/pg_eventstore/extensions/callback_handlers_extension.rb

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module Extensions
+    # @!visibility private
     module CallbackHandlersExtension
       def self.included(klass)
         klass.extend(ClassMethods)

data/lib/pg_eventstore/pg_connection.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgEventstore
+  # @!visibility private
   class PgConnection < PG::Connection
     def exec(sql)
       log(sql, [])

data/lib/pg_eventstore/query_builders/events_filtering.rb

@@ -82,7 +82,7 @@ module PgEventstore
         # @return [Array<String>]
         def extract_event_types_filter(options)
           options in { filter: { event_types: Array => event_types } }
-          event_types&.select! do
+          event_types = event_types&.select do
             _1.is_a?(String)
           end
           event_types || []

data/lib/pg_eventstore/query_builders/partitions_filtering.rb

@@ -13,7 +13,7 @@ module PgEventstore
         # @return [Array<String>]
         def extract_event_types_filter(options)
           options in { filter: { event_types: Array => event_types } }
-          event_types&.select! do
+          event_types = event_types&.select do
             _1.is_a?(String)
           end
           event_types || []

data/lib/pg_eventstore/subscriptions/basic_runner.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module PgEventstore
-  # Implements simple background jobs runner. The job execution is done via declaring a callback on the specific
-  # action. The implementation also allows you to hook into different places of life cycle of the runner by defining
-  # callbacks on various actions. Here is the list of available actions:
+  # Implements simple background job runner. A job execution is done via declaring a callback on a specific action. The
+  # implementation also allows you to hook into different places of life cycle of the runner by defining callbacks on
+  # various actions. Here is the list of available actions:
   # - :before_runner_started. Happens before the runner's state switches from "initial"/"stopped" to "running" and
   #   runner's thread is started. It is also fired when the runner is restoring - right after :before_runner_restored
   #   action.
@@ -24,12 +24,41 @@ module PgEventstore
   #
   #     def_delegators :@basic_runner, :start, :stop, :wait_for_finish, :stop_async, :restore
   #
+  #     class SimpleRecoveryStrategy
+  #       include PgEventstore::RunnerRecoveryStrategy
+  #
+  #       def initialize(restore_func)
+  #         @attempts_count = 0
+  #         @restore_func = restore_func
+  #       end
+  #
+  #       def recovers?(error)
+  #         error.message.include?("I can not handle this any more!")
+  #       end
+  #
+  #       def recover(error)
+  #         (@attempts_count < 3).tap do |res|
+  #           @attempts_count += 1
+  #           @restore_func.call if res
+  #         end
+  #       end
+  #     end
+  #
   #     def initialize
-  #       @basic_runner = PgEventstore::BasicRunner.new(1, 2)
+  #       @basic_runner = PgEventstore::BasicRunner.new(
+  #         run_interval: 1, async_shutdown_time: 2, recovery_strategies: recovery_strategies
+  #       )
   #       @jobs_performed = 0
+  #       @jobs_limit = 3
   #       attach_runner_callbacks
   #     end
   #
+  #     protected
+  #
+  #     def work_harder
+  #       @jobs_limit += 3
+  #     end
+  #
   #     private
   #
   #     def attach_runner_callbacks
@@ -42,7 +71,7 @@ module PgEventstore
   #     end
   #
   #     def process_action
-  #       raise "What's the point? I can not handle this any more!" if @jobs_performed >= 3
+  #       raise "What's the point? I can not handle this any more!" if @jobs_performed >= @jobs_limit
   #       puts "Doing some heavy lifting job"
   #       sleep 2 # Simulate long running job
   #     end
@@ -67,6 +96,10 @@ module PgEventstore
   #     def after_runner_died(error)
   #       puts "Error occurred: #{error.inspect}"
   #     end
+  #
+  #     def recovery_strategies
+  #       [SimpleRecoveryStrategy.new(method(:work_harder))]
+  #     end
   #   end
   #
   #   runner = MyAwesomeRunner.new
@@ -85,11 +118,13 @@ module PgEventstore
     #   :after_runner_stopped callback
     # @param async_shutdown_time [Integer, Float] seconds. Determines how long to wait before force-shutdown the runner.
     #   It is only meaningful for the #stop_async
-    def initialize(run_interval, async_shutdown_time)
+    def initialize(run_interval:, async_shutdown_time:, recovery_strategies: [])
       @run_interval = run_interval
       @async_shutdown_time = async_shutdown_time
+      @recovery_strategies = recovery_strategies
       @state = RunnerState.new
       @mutex = Thread::Mutex.new
+      @runner = nil
       delegate_change_state_cbx
     end
 
@@ -127,36 +162,40 @@ module PgEventstore
       synchronize do
         return self unless @state.running? || @state.dead?
 
-        @state.halting!
-        Thread.new do
-          stopping_at = Time.now.utc
-          halt = false
-          loop do
-            synchronize do
-              # Give the runner up to @async_shutdown_time seconds for graceful shutdown
-              @runner&.exit if Time.now.utc - stopping_at > @async_shutdown_time
+        begin
+          @state.halting!
+        ensure
+          Thread.new do
+            stopping_at = Time.now.utc
+            halt = false
+            loop do
+              synchronize do
+                # Give the runner up to @async_shutdown_time seconds for graceful shutdown
+                @runner&.exit if Time.now.utc - stopping_at > @async_shutdown_time
+
+                unless @runner&.alive?
+                  @state.stopped!
+                  callbacks.run_callbacks(:after_runner_stopped)
+                end
+              ensure
+                next if @runner&.alive?
 
-              unless @runner&.alive?
-                @state.stopped!
                 @runner = nil
-                callbacks.run_callbacks(:after_runner_stopped)
                 halt = true
               end
+              break if halt
+              sleep 0.1
             end
-            break if halt
-            sleep 0.1
           end
         end
-        self
       end
+      self
     end
 
     # Restores the runner after its death.
     # @return [self]
     def restore
-      synchronize do
-        return self unless @state.dead?
-
+      within_state(:dead) do
         callbacks.run_callbacks(:before_runner_restored)
         _start
       end
@@ -183,7 +222,7 @@ module PgEventstore
     end
 
     # @param state [Symbol]
-    # @return [Object] a result of evaluating of passed block
+    # @return [Object, nil] a result of evaluating of passed block
     def within_state(state, &blk)
       synchronize do
         return unless @state.public_send("#{RunnerState::STATES.fetch(state)}?")
@@ -192,6 +231,20 @@ module PgEventstore
       end
     end
 
+    protected
+
+    # @param error [StandardError]
+    # @param strategy [PgEventstore::RunnerRecoveryStrategy]
+    # @param current_runner_id [Integer]
+    # @return [Thread]
+    def async_recover(error, strategy, current_runner_id)
+      Thread.new do
+        init_recovery_ripper(current_runner_id)
+        Thread.current.exit unless strategy.recover(error)
+        recoverable { restore }
+      end
+    end
+
     private
 
     def synchronize
@@ -201,19 +254,15 @@ module PgEventstore
     # @return [void]
     def _start
       @state.running!
+    ensure
       @runner = Thread.new do
-        loop do
-          Thread.current.exit unless @state.running?
-          sleep @run_interval
-
-          callbacks.run_callbacks(:process_async)
-        end
-      rescue => error
-        synchronize do
-          raise unless @state.halting? || @state.running?
+        recoverable do
+          loop do
+            Thread.current.exit unless @state.running?
+            sleep @run_interval
 
-          @state.dead!
-          callbacks.run_callbacks(:after_runner_died, error)
+            callbacks.run_callbacks(:process_async)
+          end
         end
       end
     end
@@ -228,5 +277,43 @@ module PgEventstore
     def change_state(...)
       callbacks.run_callbacks(:change_state, ...)
     end
+
+    # @param error [StandardError]
+    # @return [PgEventstore::RunnerRecoveryStrategy, nil]
+    def suitable_strategy(error)
+      @recovery_strategies.find { _1.recovers?(error) }
+    end
+
+    # @return [void]
+    def recoverable
+      yield
+    rescue => error
+      synchronize do
+        raise unless @state.halting? || @state.running?
+
+        recovery_strategy = suitable_strategy(error)
+        @state.dead!
+        callbacks.run_callbacks(:after_runner_died, error)
+      ensure
+        async_recover(error, recovery_strategy, @runner.__id__) if recovery_strategy
+      end
+    end
+
+    # @param current_runner_id [Integer]
+    # @return [Thread]
+    def init_recovery_ripper(current_runner_id)
+      recovery_job = Thread.current
+      Thread.new do
+        loop do
+          synchronize do
+            recovery_job.exit unless @state.dead?
+            recovery_job.exit unless current_runner_id == @runner.__id__
+          end
+          break unless recovery_job.alive?
+
+          sleep 1
+        end
+      end
+    end
   end
 end

data/lib/pg_eventstore/subscriptions/callback_handlers/commands_handler_handlers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgEventstore
+  # @!visibility private
   class CommandsHandlerHandlers
     include Extensions::CallbackHandlersExtension
 
@@ -19,20 +20,6 @@ module PgEventstore
       def process_runners_commands(config_name, runners, subscription_feeder)
         CommandHandlers::SubscriptionRunnersCommands.new(config_name, runners, subscription_feeder.id).process
       end
-
-      # @param basic_runner [PgEventstore::BasicRunner]
-      # @param restart_delay [Integer]
-      # @param error [StandardError]
-      # @return [void]
-      def restore_runner(basic_runner, restart_delay, error)
-        PgEventstore.logger&.error "PgEventstore::CommandsHandler: Error occurred: #{error.message}"
-        PgEventstore.logger&.error "PgEventstore::CommandsHandler: Backtrace: #{error.backtrace&.join("\n")}"
-        PgEventstore.logger&.error "PgEventstore::CommandsHandler: Trying to auto-repair in #{restart_delay} seconds..."
-        Thread.new do
-          sleep restart_delay
-          basic_runner.restore
-        end
-      end
     end
   end
 end

data/lib/pg_eventstore/subscriptions/callback_handlers/events_processor_handlers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgEventstore
+  # @!visibility private
   class EventsProcessorHandlers
     include Extensions::CallbackHandlersExtension
 
@@ -15,10 +16,10 @@ module PgEventstore
 
         callbacks.run_callbacks(:process, Utils.original_global_position(raw_event)) do
           handler.call(raw_event)
+        rescue => exception
+          raw_events.unshift(raw_event)
+          raise Utils.wrap_exception(exception, global_position: Utils.original_global_position(raw_event))
         end
-      rescue => exception
-        raw_events.unshift(raw_event)
-        raise Utils.wrap_exception(exception, global_position: Utils.original_global_position(raw_event))
       end
 
       # @param callbacks [PgEventstore::Callbacks]

data/lib/pg_eventstore/subscriptions/callback_handlers/subscription_feeder_handlers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgEventstore
+  # @!visibility private
   class SubscriptionFeederHandlers
     include Extensions::CallbackHandlersExtension
 
@@ -39,20 +40,6 @@ module PgEventstore
         )
       end
 
-      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
-      # @param basic_runner [PgEventstore::BasicRunner]
-      # @param _error [StandardError]
-      # @return [void]
-      def restart_runner(subscriptions_set_lifecycle, basic_runner, _error)
-        subscriptions_set = subscriptions_set_lifecycle.persisted_subscriptions_set
-        return if subscriptions_set.restart_count >= subscriptions_set.max_restarts_number
-
-        Thread.new do
-          sleep subscriptions_set.time_between_restarts
-          basic_runner.restore
-        end
-      end
-
       # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
       # @return [void]
       def ping_subscriptions_set(subscriptions_set_lifecycle)

data/lib/pg_eventstore/subscriptions/callback_handlers/subscription_runner_handlers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgEventstore
+  # @!visibility private
   class SubscriptionRunnerHandlers
     include Extensions::CallbackHandlersExtension
 
@@ -32,25 +33,6 @@ module PgEventstore
         subscription.update(last_error: Utils.error_info(error), last_error_occurred_at: Time.now.utc)
       end
 
-      # @param subscription [PgEventstore::Subscription]
-      # @param restart_terminator [#call, nil]
-      # @param failed_subscription_notifier [#call, nil]
-      # @param events_processor [PgEventstore::EventsProcessor]
-      # @param error [PgEventstore::WrappedException]
-      # @return [void]
-      def restart_events_processor(subscription, restart_terminator, failed_subscription_notifier, events_processor,
-                                   error)
-        return if restart_terminator&.call(subscription.dup)
-        if subscription.restart_count >= subscription.max_restarts_number
-          return failed_subscription_notifier&.call(subscription.dup, Utils.unwrap_exception(error))
-        end
-
-        Thread.new do
-          sleep subscription.time_between_restarts
-          events_processor.restore
-        end
-      end
-
       # @param subscription [PgEventstore::Subscription]
       # @param global_position [Integer]
       # @return [void]

data/lib/pg_eventstore/subscriptions/command_handlers/subscription_feeder_commands.rb

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module CommandHandlers
+    # @!visibility private
     class SubscriptionFeederCommands
       # @param config_name [Symbol]
       # @param subscription_feeder [PgEventstore::SubscriptionFeeder]

data/lib/pg_eventstore/subscriptions/command_handlers/subscription_runners_commands.rb

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module CommandHandlers
+    # @!visibility private
     class SubscriptionRunnersCommands
       # @param config_name [Symbol]
       # @param runners [Array<PgEventstore::SubscriptionRunner>]

data/lib/pg_eventstore/subscriptions/commands_handler.rb

@@ -10,8 +10,6 @@ module PgEventstore
   class CommandsHandler
     extend Forwardable
 
-    # @return [Integer] the delay in seconds between runner restarts
-    RESTART_DELAY = 5
     # @return [Integer] seconds, how often to check for new commands
     PULL_INTERVAL = 1
 
@@ -24,7 +22,11 @@ module PgEventstore
       @config_name = config_name
       @subscription_feeder = subscription_feeder
       @runners = runners
-      @basic_runner = BasicRunner.new(PULL_INTERVAL, 0)
+      @basic_runner = BasicRunner.new(
+        run_interval: PULL_INTERVAL,
+        async_shutdown_time: 0,
+        recovery_strategies: [RunnerRecoveryStrategies::RestoreConnection.new(config_name)]
+      )
       attach_runner_callbacks
     end
 
@@ -39,11 +41,6 @@ module PgEventstore
         :process_async, :before,
         CommandsHandlerHandlers.setup_handler(:process_runners_commands, @config_name, @runners, @subscription_feeder)
       )
-
-      @basic_runner.define_callback(
-        :after_runner_died, :before,
-        CommandsHandlerHandlers.setup_handler(:restore_runner, @basic_runner, RESTART_DELAY)
-      )
     end
   end
 end

data/lib/pg_eventstore/subscriptions/events_processor.rb

@@ -13,10 +13,15 @@ module PgEventstore
     # @param handler [#call]
     # @param graceful_shutdown_timeout [Integer, Float] seconds. Determines how long to wait before force-shutdown
     #   the runner when stopping it using #stop_async
-    def initialize(handler, graceful_shutdown_timeout:)
+    # @param recovery_strategies [Array<PgEventstore::RunnerRecoveryStrategy>]
+    def initialize(handler, graceful_shutdown_timeout:, recovery_strategies: [])
       @handler = handler
       @raw_events = []
-      @basic_runner = BasicRunner.new(0, graceful_shutdown_timeout)
+      @basic_runner = BasicRunner.new(
+        run_interval: 0,
+        async_shutdown_time: graceful_shutdown_timeout,
+        recovery_strategies: recovery_strategies
+      )
       attach_runner_callbacks
     end
 

data/lib/pg_eventstore/subscriptions/extensions/base_command_extension.rb

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module Extensions
+    # @!visibility private
     module BaseCommandExtension
       def self.included(klass)
         super