pg_eventstore 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80f70b0a0704b224854bda8c4d0a5ffeba9dad355cb44233e84146ece3dcc9fc
-  data.tar.gz: '0682683f6b68f27dbf9ec88af1804ff82995ebb899c56ea40595b79ab68afe48'
+  metadata.gz: ec41b398e1f38d66e73967447ea4f12896ed2cf57eb0dbad8b71acf4257f9cd4
+  data.tar.gz: ce571ef411adeeb18b7bae463cac339a053d96f1b36e3de0b1023b8551b03ac5
 SHA512:
-  metadata.gz: 47adc4ffc8200caf20e26ce4e436c3f5609e78f378fd1345639c56d39db2af7489a7790e7924c9c4316055771424aae062eb4a55ee3070d82d12f80411aa5198
-  data.tar.gz: 0b512311767198a395897f27177e2c9e24280d99763f2aa23cd40021d2969c6d0a93886240a3407ea9ef4067f7d26847fe6b349bcab9040df64bf16f4a8058a7
+  metadata.gz: 9273a4efb9855d219b1a92b5d9081e3d0d62f9de7f21c48e634949d218ed6a8278d81367f794ee8b70efa64541d7a4442ccf09e7b4cc3bcbd39398f5c7980ec2
+  data.tar.gz: ffb85f8c9063aa6e11b8f900e128b4b873e89db117b39e703de6603fc73c014811b63950ff0a0340b0316da11ed2562418f56f1faf42a04491fb0105d913fced

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [1.5.0]
+- Add ability to toggle link events in the admin UI
+- Mark linked events in the admin UI with "link" icon
+
 ## [1.4.0]
 - Add an ability to configure subscription graceful shutdown timeout globally and per subscription. Default value is 15 seconds. Previously it was hardcoded to 5 seconds. Examples:
 

data/lib/pg_eventstore/extensions/callback_handlers_extension.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Extensions
+    module CallbackHandlersExtension
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # @param name [Symbol] a name of the handler
+        # @return [Proc]
+        def setup_handler(name, *args)
+          proc do |*rest|
+            public_send(name, *args, *rest)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class CommandsHandlerHandlers
+    include Extensions::CallbackHandlersExtension
+
+    class << self
+      # @param config_name [Symbol]
+      # @param subscription_feeder [PgEventstore::SubscriptionFeeder]
+      # @return [void]
+      def process_feeder_commands(config_name, subscription_feeder)
+        CommandHandlers::SubscriptionFeederCommands.new(config_name, subscription_feeder).process
+      end
+
+      # @param config_name [Symbol]
+      # @param runners [Array<PgEventstore::SubscriptionRunner>]
+      # @param subscription_feeder [PgEventstore::SubscriptionFeeder]
+      # @return [void]
+      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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class EventsProcessorHandlers
+    include Extensions::CallbackHandlersExtension
+
+    class << self
+      # @param callbacks [PgEventstore::Callbacks]
+      # @param handler [#call]
+      # @param raw_events [Array<Hash>]
+      # @return [void]
+      def process_event(callbacks, handler, raw_events)
+        raw_event = raw_events.shift
+        return sleep 0.5 if raw_event.nil?
+
+        callbacks.run_callbacks(:process, Utils.original_global_position(raw_event)) do
+          handler.call(raw_event)
+        end
+      rescue
+        raw_events.unshift(raw_event)
+        raise
+      end
+
+      # @param callbacks [PgEventstore::Callbacks]
+      # @param error [StandardError]
+      # @return [void]
+      def after_runner_died(callbacks, error)
+        callbacks.run_callbacks(:error, error)
+      end
+
+      # @param callbacks [PgEventstore::Callbacks]
+      # @return [void]
+      def before_runner_restored(callbacks)
+        callbacks.run_callbacks(:restart)
+      end
+
+      # @param callbacks [PgEventstore::Callbacks]
+      # @param state [String]
+      # @return [void]
+      def change_state(callbacks, state)
+        callbacks.run_callbacks(:change_state, state)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class SubscriptionFeederHandlers
+    include Extensions::CallbackHandlersExtension
+
+    class << self
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @param state [String]
+      # @return [void]
+      def update_subscriptions_set_state(subscriptions_set_lifecycle, state)
+        subscriptions_set_lifecycle.persisted_subscriptions_set.update(state: state)
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @return [void]
+      def lock_subscriptions(subscriptions_lifecycle)
+        subscriptions_lifecycle.lock_all
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @return [void]
+      def start_runners(subscriptions_lifecycle)
+        subscriptions_lifecycle.runners.each(&:start)
+      end
+
+      # @param cmds_handler [PgEventstore::CommandsHandler]
+      # @return [void]
+      def start_cmds_handler(cmds_handler)
+        cmds_handler.start
+      end
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @param error [StandardError]
+      # @return [void]
+      def persist_error_info(subscriptions_set_lifecycle, error)
+        subscriptions_set_lifecycle.persisted_subscriptions_set.update(
+          last_error: Utils.error_info(error), last_error_occurred_at: Time.now.utc
+        )
+      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)
+        subscriptions_set_lifecycle.ping_subscriptions_set
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @param config_name [Symbol]
+      # @return [void]
+      def feed_runners(subscriptions_lifecycle, config_name)
+        SubscriptionRunnersFeeder.new(config_name).feed(subscriptions_lifecycle.runners)
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @return [void]
+      def ping_subscriptions(subscriptions_lifecycle)
+        subscriptions_lifecycle.ping_subscriptions
+      end
+
+      # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+      # @return [void]
+      def stop_runners(subscriptions_lifecycle)
+        subscriptions_lifecycle.runners.each(&:stop_async).each(&:wait_for_finish)
+      end
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @return [void]
+      def reset_subscriptions_set(subscriptions_set_lifecycle)
+        subscriptions_set_lifecycle.reset_subscriptions_set
+      end
+
+      # @param cmds_handler [PgEventstore::CommandsHandler]
+      # @return [void]
+      def stop_commands_handler(cmds_handler)
+        cmds_handler.stop
+      end
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      # @return [void]
+      def update_subscriptions_set_restarts(subscriptions_set_lifecycle)
+        subscriptions_set = subscriptions_set_lifecycle.persisted_subscriptions_set
+        subscriptions_set.update(
+          last_restarted_at: Time.now.utc, restart_count: subscriptions_set.restart_count + 1
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class SubscriptionRunnerHandlers
+    include Extensions::CallbackHandlersExtension
+
+    class << self
+      # @param stats [PgEventstore::SubscriptionHandlerPerformance]
+      # @param action [Proc]
+      # @param _current_position [Integer]
+      # @return [void]
+      def track_exec_time(stats, action, _current_position)
+        stats.track_exec_time { action.call }
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param stats [PgEventstore::SubscriptionHandlerPerformance]
+      # @param current_position [Integer]
+      # @return [void]
+      def update_subscription_stats(subscription, stats, current_position)
+        subscription.update(
+          average_event_processing_time: stats.average_event_processing_time,
+          current_position: current_position,
+          total_processed_events: subscription.total_processed_events + 1
+        )
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param error [StandardError]
+      # @return [void]
+      def update_subscription_error(subscription, error)
+        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 [StandardError]
+      # @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, 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]
+      def update_subscription_chunk_stats(subscription, global_position)
+        subscription.update(last_chunk_fed_at: Time.now.utc, last_chunk_greatest_position: global_position)
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @return [void]
+      def update_subscription_restarts(subscription)
+        subscription.update(last_restarted_at: Time.now.utc, restart_count: subscription.restart_count + 1)
+      end
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param state [String]
+      # @return [void]
+      def update_subscription_state(subscription, state)
+        subscription.update(state: state)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/commands_handler.rb

@@ -31,35 +31,19 @@ module PgEventstore
     private
 
     def attach_runner_callbacks
-      @basic_runner.define_callback(:process_async, :before, method(:process_async))
-      @basic_runner.define_callback(:after_runner_died, :before, method(:after_runner_died))
-    end
-
-    def process_async
-      subscription_feeder_commands.process
-      subscription_runners_commands.process
-    end
-
-    # @param error [StandardError]
-    # @return [void]
-    def after_runner_died(error)
-      PgEventstore.logger&.error "#{self.class.name}: Error occurred: #{error.message}"
-      PgEventstore.logger&.error "#{self.class.name}: Backtrace: #{error.backtrace&.join("\n")}"
-      PgEventstore.logger&.error "#{self.class.name}: Trying to auto-repair in #{RESTART_DELAY} seconds..."
-      Thread.new do
-        sleep RESTART_DELAY
-        @basic_runner.restore
-      end
-    end
-
-    # @return [PgEventstore::CommandHandlers::SubscriptionFeederCommands]
-    def subscription_feeder_commands
-      CommandHandlers::SubscriptionFeederCommands.new(@config_name, @subscription_feeder)
-    end
-
-    # @return [PgEventstore::CommandHandlers::SubscriptionRunnersCommands]
-    def subscription_runners_commands
-      CommandHandlers::SubscriptionRunnersCommands.new(@config_name, @runners, @subscription_feeder.id)
+      @basic_runner.define_callback(
+        :process_async, :before,
+      CommandsHandlerHandlers.setup_handler(:process_feeder_commands, @config_name, @subscription_feeder)
+      )
+      @basic_runner.define_callback(
+        :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

@@ -26,7 +26,7 @@ module PgEventstore
       raise EmptyChunkFedError.new("Empty chunk was fed!") if raw_events.empty?
 
       within_state(:running) do
-        callbacks.run_callbacks(:feed, global_position(raw_events.last))
+        callbacks.run_callbacks(:feed, Utils.original_global_position(raw_events.last))
         @raw_events.push(*raw_events)
       end
     end
@@ -44,47 +44,23 @@ module PgEventstore
 
     private
 
-    # @param raw_event [Hash]
-    # @return [void]
-    def process_event(raw_event)
-      callbacks.run_callbacks(:process, global_position(raw_event)) do
-        @handler.call(raw_event)
-      end
-    end
-
     def attach_runner_callbacks
-      @basic_runner.define_callback(:process_async, :before, method(:process_async))
-      @basic_runner.define_callback(:after_runner_died, :before, method(:after_runner_died))
-      @basic_runner.define_callback(:before_runner_restored, :before, method(:before_runner_restored))
-      @basic_runner.define_callback(:change_state, :before, method(:change_state))
-    end
-
-    def process_async
-      raw_event = @raw_events.shift
-      return sleep 0.5 if raw_event.nil?
-
-      process_event(raw_event)
-    rescue
-      @raw_events.unshift(raw_event)
-      raise
-    end
-
-    def after_runner_died(...)
-      callbacks.run_callbacks(:error, ...)
-    end
-
-    def before_runner_restored
-      callbacks.run_callbacks(:restart)
-    end
-
-    def change_state(...)
-      callbacks.run_callbacks(:change_state, ...)
-    end
-
-    # @param raw_event [Hash]
-    # @return [Integer]
-    def global_position(raw_event)
-      raw_event['link'] ? raw_event['link']['global_position'] : raw_event['global_position']
+      @basic_runner.define_callback(
+        :process_async, :before,
+        EventsProcessorHandlers.setup_handler(:process_event, @callbacks, @handler, @raw_events)
+      )
+
+      @basic_runner.define_callback(
+        :after_runner_died, :before, EventsProcessorHandlers.setup_handler(:after_runner_died, callbacks)
+      )
+
+      @basic_runner.define_callback(
+        :before_runner_restored, :before, EventsProcessorHandlers.setup_handler(:before_runner_restored, callbacks)
+      )
+
+      @basic_runner.define_callback(
+        :change_state, :before, EventsProcessorHandlers.setup_handler(:change_state, callbacks)
+      )
     end
   end
 end