pg_eventstore 1.5.0 → 1.6.0

data/lib/pg_eventstore/cli/try_to_delete_subscriptions_set.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module CLI
+    class TryToDeleteSubscriptionsSet
+      class << self
+        def try_to_delete(...)
+          new(...).try_to_delete
+        end
+      end
+
+      attr_reader :config_name, :subscriptions_set_id
+
+      # @param config_name [Symbol]
+      # @param subscriptions_set_id [Integer]
+      def initialize(config_name, subscriptions_set_id)
+        @config_name = config_name
+        @subscriptions_set_id = subscriptions_set_id
+      end
+
+      # @return [Boolean] whether subscription was deleted
+      def try_to_delete
+        PgEventstore.logger&.info(
+          "Trying to delete SubscriptionsSet##{subscriptions_set_id}."
+        )
+        cmd_name = SubscriptionFeederCommands.command_class('Ping').new.name
+        subscriptions_set_commands_queries.find_or_create_by(
+          subscriptions_set_id: subscriptions_set_id, command_name: cmd_name, data: {}
+        )
+        # 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
+        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)
+          PgEventstore.logger&.info(
+            "SubscriptionsSet##{subscriptions_set_id} was deleted successfully. Proceeding with startup process."
+          )
+          return true
+        end
+
+        PgEventstore.logger&.warn(
+          "Failed to delete SubscriptionsSet##{subscriptions_set_id}. It looks alive."
+        )
+        false
+      rescue RecordNotFound
+        # Failed to create "Ping" command because related SubscriptionsSet does not exist.
+        true
+      end
+
+      private
+
+      # @return [PgEventstore::SubscriptionsSetQueries]
+      def subscriptions_set_queries
+        SubscriptionsSetQueries.new(connection)
+      end
+
+      # @return [PgEventstore::SubscriptionsSetCommandQueries]
+      def subscriptions_set_commands_queries
+        SubscriptionsSetCommandQueries.new(connection)
+      end
+
+      # @return [PgEventstore::Connection]
+      def connection
+        PgEventstore.connection(config_name)
+      end
+
+      # @return [PgEventstore::Config]
+      def config
+        PgEventstore.config(config_name)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/cli/try_unlock_subscriptions_set.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'try_to_delete_subscriptions_set'
+require_relative 'wait_for_subscriptions_set_shutdown'
+
+module PgEventstore
+  module CLI
+    class TryUnlockSubscriptionsSet
+      class << self
+        def try_unlock(...)
+          TryToDeleteSubscriptionsSet.try_to_delete(...) || WaitForSubscriptionsSetShutdown.wait_for_shutdown(...)
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/cli/wait_for_subscriptions_set_shutdown.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module CLI
+    class WaitForSubscriptionsSetShutdown
+      class << self
+        def wait_for_shutdown(...)
+          new(...).wait_for_shutdown
+        end
+      end
+
+      # @return [Float] seconds
+      SHUTDOWN_CHECK_INTERVAL = 2.0
+
+      attr_reader :config_name, :subscriptions_set_id
+
+      # @param config_name [Symbol]
+      # @param subscriptions_set_id [Integer]
+      def initialize(config_name, subscriptions_set_id)
+        @config_name = config_name
+        @subscriptions_set_id = subscriptions_set_id
+      end
+
+      # @return [Boolean]
+      def wait_for_shutdown
+        PgEventstore.logger&.info(
+          "Trying to wait for shutdown of SubscriptionsSet##{subscriptions_set_id}."
+        )
+        deadline = Time.now.utc + config.subscription_graceful_shutdown_timeout
+        loop do
+          find_set!
+          return false if Time.now.utc > deadline
+
+          sleep SHUTDOWN_CHECK_INTERVAL
+        end
+      rescue RecordNotFound
+        PgEventstore.logger&.warn(
+          "SubscriptionsSet##{subscriptions_set_id} no longer exists. Proceeding with startup process."
+        )
+        true
+      end
+
+      private
+
+      # @return [PgEventstore::SubscriptionsSetQueries]
+      def subscriptions_set_queries
+        SubscriptionsSetQueries.new(connection)
+      end
+
+      # @return [PgEventstore::SubscriptionsSet]
+      # @raise [PgEventstore::RecordNotFound]
+      def find_set!
+        SubscriptionsSet.using_connection(config_name).new(**subscriptions_set_queries.find!(subscriptions_set_id))
+      end
+
+      # @return [PgEventstore::Connection]
+      def connection
+        PgEventstore.connection(config_name)
+      end
+
+      # @return [PgEventstore::Config]
+      def config
+        PgEventstore.config(config_name)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/cli.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require_relative 'cli/parsers'
+require_relative 'cli/parser_options'
+require_relative 'cli/try_unlock_subscriptions_set'
+require_relative 'cli/exit_codes'
+require_relative 'cli/commands'
+
+module PgEventstore
+  module CLI
+    OPTIONS_PARSER = {
+      "subscriptions" => [Parsers::SubscriptionParser, ParserOptions::SubscriptionOptions].freeze
+    }.tap do |directions|
+      directions.default = [Parsers::DefaultParser, ParserOptions::DefaultOptions].freeze
+    end.freeze
+
+    COMMANDS = {
+      ["subscriptions", "start"].freeze => Commands::StartSubscriptionsCommand,
+      ["subscriptions", "stop"].freeze => Commands::StopSubscriptionsCommand
+    }.freeze
+
+    class << self
+      # @return [PgEventstore::Callbacks]
+      def callbacks
+        @callbacks ||= Callbacks.new
+      end
+
+      # @param args [Array<String>]
+      # @return [Integer] exit code
+      def execute(args)
+        options_parser_class, options_class = OPTIONS_PARSER[args[0]]
+        command, parsed_options = options_parser_class.new(ARGV, options_class.new).parse
+        return Commands::HelpCommand.new(parsed_options).call if parsed_options.help
+        return COMMANDS[command].new(parsed_options).call if COMMANDS[command]
+
+        _, parsed_options = options_parser_class.new(['-h'], options_class.new).parse
+        Commands::HelpCommand.new(parsed_options).call
+      end
+    end
+  end
+end

data/lib/pg_eventstore/extensions/options_extension.rb

@@ -40,14 +40,59 @@ module PgEventstore
     #
     #   SomeClass.new(attr1: 'hihi', attr4: 'byebye')
     module OptionsExtension
+      class Option
+        attr_reader :name, :metadata
+
+        # @param name [Symbol]
+        # @param metadata [Object, nil]
+        def initialize(name, metadata: nil)
+          @name = name
+          @metadata = metadata
+        end
+
+        # @param other_option [Object]
+        # @return [Boolean]
+        def ==(other_option)
+          return false unless other_option.is_a?(Option)
+
+          name == other_option.name
+        end
+
+        # @param other_option [Object]
+        # @return [Boolean]
+        def eql?(other_option)
+          return false unless other_option.is_a?(Option)
+
+          name.eql?(other_option.name)
+        end
+
+        # @return [Integer]
+        def hash
+          name.hash
+        end
+      end
+
+      class Options < Set
+        def add(o)
+          @hash[o] = o
+          self
+        end
+
+        # @param option [Symbol]
+        # @return [PgEventstore::Extensions::OptionsExtension::Option, nil]
+        def [](option)
+          @hash[Option.new(option)]
+        end
+      end
+
       # @!visibility private
       module ClassMethods
         # @param opt_name [Symbol] option name
         # @param blk [Proc] provide define value using block. It will be later evaluated in the
         #   context of your object to determine the default value of the option
         # @return [Symbol]
-        def option(opt_name, &blk)
-          self.options = (options + Set.new([opt_name])).freeze
+        def option(opt_name, metadata: nil, &blk)
+          self.options = (options + Options.new([Option.new(opt_name, metadata: metadata)])).freeze
           warn_already_defined(opt_name)
           warn_already_defined(:"#{opt_name}=")
           define_method "#{opt_name}=" do |value|
@@ -67,7 +112,7 @@ module PgEventstore
 
         def inherited(klass)
           super
-          klass.options = Set.new(options).freeze
+          klass.options = Options.new(options).freeze
         end
 
         private
@@ -86,7 +131,7 @@ module PgEventstore
 
       def self.included(klass)
         klass.singleton_class.attr_accessor(:options)
-        klass.options = Set.new.freeze
+        klass.options = Options.new.freeze
         klass.extend(ClassMethods)
       end
 
@@ -100,7 +145,7 @@ module PgEventstore
       # @return [Hash]
       def options_hash
         self.class.options.each_with_object({}) do |option, res|
-          res[option] = public_send(option)
+          res[option.name] = public_send(option.name)
         end
       end
       alias attributes_hash options_hash
@@ -108,7 +153,7 @@ module PgEventstore
       # @param opt_name [Symbol]
       # @return [Boolean]
       def readonly!(opt_name)
-        return false unless self.class.options.include?(opt_name)
+        return false unless self.class.options.include?(Option.new(opt_name))
 
         @readonly.add(opt_name)
         true
@@ -136,8 +181,8 @@ module PgEventstore
       def init_default_values(options)
         self.class.options.each do |option|
           # init default values of options
-          value = options.key?(option) ? options[option] : public_send(option)
-          public_send("#{option}=", value)
+          value = options.key?(option.name) ? options[option.name] : public_send(option.name)
+          public_send("#{option.name}=", value)
         end
       end
     end

data/lib/pg_eventstore/rspec/has_option_matcher.rb

@@ -45,25 +45,46 @@
 # end
 RSpec::Matchers.define :has_option do |option_name|
   match do |obj|
-    option_presence = obj.class.respond_to?(:options) && obj.class.options.include?(option_name)
-    if @default_value
-      option_presence && RSpec::Matchers::BuiltIn::Match.new(@default_value).matches?(obj.class.allocate.public_send(option_name))
-    else
-      option_presence
+    option = obj.class.options[option_name]
+    is_correct = obj.class.respond_to?(:options) && option
+    if defined?(@default_value)
+      is_correct &&=
+        RSpec::Matchers::BuiltIn::Match.new(@default_value).matches?(obj.class.allocate.public_send(option_name))
+    end
+    if defined?(@metadata)
+      is_correct &&= RSpec::Matchers::BuiltIn::Match.new(@metadata).matches?(option.metadata)
     end
+    is_correct
   end
 
   failure_message do |obj|
-    option_presence = obj.class.respond_to?(:options) && obj.class.options.include?(option_name)
-    if option_presence && @default_value
-      msg = "Expected #{obj.class} to have `#{option_name.inspect}' option with #{@default_value.inspect}"
-      msg += ' default value, but default value is'
-      msg += " #{obj.class.allocate.public_send(option_name).inspect}"
+    option = obj.class.options[option_name]
+    option_presence = obj.class.respond_to?(:options) && option
+
+    default_value_message = "with default value #{@default_value.inspect}"
+    metadata_message = "with metadata #{@metadata.inspect}"
+    message = "Expected #{obj.class} to have `#{option_name.inspect}' option"
+    message += " #{default_value_message}," if defined?(@default_value)
+    message += " #{metadata_message}," if defined?(@metadata)
+    message += "," unless defined?(@metadata) || defined?(@default_value)
+    if option_presence
+      actual_default_value = obj.class.allocate.public_send(option_name)
+      actual_metadata = option.metadata
+      default_value_matches = RSpec::Matchers::BuiltIn::Match.new(@default_value).matches?(actual_default_value)
+      metadata_matches = RSpec::Matchers::BuiltIn::Match.new(@metadata).matches?(actual_metadata)
+
+      case [default_value_matches, metadata_matches]
+      when [false, true]
+        message += " but default value is #{actual_default_value.inspect}"
+      when [true, false]
+        message += " but metadata is #{actual_metadata.inspect}"
+      else
+        message += " but default value is #{actual_default_value.inspect} and metadata is #{actual_metadata.inspect}"
+      end
     else
-      msg = "Expected #{obj} to have `#{option_name.inspect}' option."
+      message += " but there is no option found with the given name"
     end
-
-    msg
+    message
   end
 
   description do
@@ -83,6 +104,10 @@ RSpec::Matchers.define :has_option do |option_name|
   chain :with_default_value do |val|
     @default_value = val
   end
+
+  chain :with_metadata do |val|
+    @metadata = val
+  end
 end
 
 RSpec::Matchers.alias_matcher :have_option, :has_option

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

@@ -13,7 +13,7 @@ module PgEventstore
       # Look up commands for the given SubscriptionFeeder and execute them
       # @return [void]
       def process
-        queries.find_commands(@subscription_feeder.id).each do |command|
+        commands.each do |command|
           command.exec_cmd(@subscription_feeder)
           queries.delete(command.id)
         end
@@ -21,6 +21,18 @@ module PgEventstore
 
       private
 
+      # @return [Array<PgEventstore::SubscriptionFeederCommands::Base>]
+      def commands
+        commands = queries.find_commands(@subscription_feeder.id)
+        ping_cmd = commands.find do |cmd|
+          cmd.name == 'Ping'
+        end
+        return commands unless ping_cmd
+
+        # "Ping" command should go in prio
+        [ping_cmd, *(commands - [ping_cmd])]
+      end
+
       # @return [PgEventstore::SubscriptionsSetCommandQueries]
       def queries
         SubscriptionsSetCommandQueries.new(connection)

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

@@ -5,7 +5,7 @@ module PgEventstore
     class SubscriptionRunnersCommands
       # @param config_name [Symbol]
       # @param runners [Array<PgEventstore::SubscriptionRunner>]
-      # @param subscriptions_set_id [Integer]
+      # @param subscriptions_set_id [Integer, nil]
       def initialize(config_name, runners, subscriptions_set_id)
         @config_name = config_name
         @runners = runners.to_h { |runner| [runner.id, runner] }

data/lib/pg_eventstore/subscriptions/queries/subscription_command_queries.rb

@@ -64,7 +64,7 @@ module PgEventstore
     end
 
     # @param subscription_ids [Array<Integer>]
-    # @param subscriptions_set_id [Integer]
+    # @param subscriptions_set_id [Integer, nil]
     # @return [Array<PgEventstore::SubscriptionRunnerCommands::Base>]
     def find_commands(subscription_ids, subscriptions_set_id:)
       return [] if subscription_ids.empty?

data/lib/pg_eventstore/subscriptions/queries/subscriptions_set_command_queries.rb

@@ -55,9 +55,11 @@ module PgEventstore
         conn.exec_params(sql, [command_name, subscriptions_set_id, data])
       end
       deserialize(pg_result.to_a.first)
+    rescue PG::ForeignKeyViolation
+      raise RecordNotFound.new("subscriptions_set", subscriptions_set_id)
     end
 
-    # @param subscriptions_set_id [Integer]
+    # @param subscriptions_set_id [Integer, nil]
     # @return [Array<PgEventstore::SubscriptionFeederCommands::Base>]
     def find_commands(subscriptions_set_id)
       sql_builder =

data/lib/pg_eventstore/subscriptions/subscription_feeder.rb

@@ -6,37 +6,25 @@ module PgEventstore
   class SubscriptionFeeder
     extend Forwardable
 
-    def_delegators :@basic_runner, :start, :stop, :restore, :state, :wait_for_finish, :stop_async
-    def_delegators :@subscriptions_lifecycle, :force_lock!
+    attr_reader :config_name
+
+    def_delegators :@basic_runner, :start, :stop, :restore, :state, :wait_for_finish, :stop_async, :running?
 
     # @param config_name [Symbol]
-    # @param set_name [String]
-    # @param max_retries [Integer] max number of retries of failed SubscriptionsSet
-    # @param retries_interval [Integer] a delay between retries of failed SubscriptionsSet
-    def initialize(config_name:, set_name:, max_retries:, retries_interval:)
+    # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+    # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
+    def initialize(config_name:, subscriptions_set_lifecycle:, subscriptions_lifecycle:)
       @config_name = config_name
       @basic_runner = BasicRunner.new(0.2, 0)
-      @subscriptions_set_lifecycle = SubscriptionsSetLifecycle.new(
-        @config_name,
-        { name: set_name, max_restarts_number: max_retries, time_between_restarts: retries_interval }
-      )
-      @subscriptions_lifecycle = SubscriptionsLifecycle.new(@config_name, @subscriptions_set_lifecycle)
+      @subscriptions_set_lifecycle = subscriptions_set_lifecycle
+      @subscriptions_lifecycle = subscriptions_lifecycle
       @commands_handler = CommandsHandler.new(@config_name, self, @subscriptions_lifecycle.runners)
       attach_runner_callbacks
     end
 
-    # @return [Integer]
+    # @return [Integer, nil]
     def id
-      @subscriptions_set_lifecycle.persisted_subscriptions_set.id
-    end
-
-    # Adds SubscriptionRunner to the set
-    # @param runner [PgEventstore::SubscriptionRunner]
-    # @return [PgEventstore::SubscriptionRunner]
-    def add(runner)
-      assert_proper_state!
-      @subscriptions_lifecycle.runners.push(runner)
-      runner
+      @subscriptions_set_lifecycle.subscriptions_set&.id
     end
 
     # Starts all SubscriptionRunners. This is only available if SubscriptionFeeder's runner is alive.
@@ -57,20 +45,6 @@ module PgEventstore
       self
     end
 
-    # Produces a copy of currently running Subscriptions. This is needed, because original Subscriptions objects are
-    # dangerous to use - users may incidentally break their state.
-    # @return [Array<PgEventstore::Subscription>]
-    def read_only_subscriptions
-      @subscriptions_lifecycle.subscriptions.map(&:dup)
-    end
-
-    # Produces a copy of current SubscriptionsSet. This is needed, because original SubscriptionsSet object is
-    # dangerous to use - users may incidentally break its state.
-    # @return [PgEventstore::SubscriptionsSet, nil]
-    def read_only_subscriptions_set
-      @subscriptions_set_lifecycle.subscriptions_set&.dup
-    end
-
     private
 
     # @return [void]
@@ -133,19 +107,5 @@ module PgEventstore
         SubscriptionFeederHandlers.setup_handler(:update_subscriptions_set_restarts, @subscriptions_set_lifecycle)
       )
     end
-
-    # This method helps to ensure that no Subscription is added after SubscriptionFeeder's runner is working
-    # @return [void]
-    # @raise [RuntimeError]
-    def assert_proper_state!
-      return if @basic_runner.initial? || @basic_runner.stopped?
-      subscriptions_set = @subscriptions_set_lifecycle.persisted_subscriptions_set
-
-      error_message = <<~TEXT
-        Could not add subscription - #{subscriptions_set.name}##{subscriptions_set.id} must be \
-        either in the initial or in the stopped state, but it is in the #{@basic_runner.state} state now.
-      TEXT
-      raise error_message
-    end
   end
 end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module SubscriptionFeederCommands
+    # @!visibility private
+    class Ping < Base
+      # @param subscription_feeder [PgEventstore::SubscriptionFeeder]
+      # @return [void]
+      def exec_cmd(subscription_feeder)
+        queries(subscription_feeder.config_name).update(subscriptions_set_id, {})
+      end
+
+      private
+
+      # @param config_name [Symbol]
+      # @return [PgEventstore::SubscriptionsSetQueries]
+      def queries(config_name)
+        SubscriptionsSetQueries.new(PgEventstore.connection(config_name))
+      end
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/subscription_feeder_commands.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'subscription_feeder_commands/base'
+require_relative 'subscription_feeder_commands/ping'
 require_relative 'subscription_feeder_commands/restore'
 require_relative 'subscription_feeder_commands/start_all'
 require_relative 'subscription_feeder_commands/stop'

data/lib/pg_eventstore/subscriptions/subscriptions_lifecycle.rb

@@ -13,12 +13,12 @@ module PgEventstore
 
     # @param config_name [Symbol]
     # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
-    def initialize(config_name, subscriptions_set_lifecycle)
+    def initialize(config_name, subscriptions_set_lifecycle, force_lock: false)
       @config_name = config_name
       @subscriptions_set_lifecycle = subscriptions_set_lifecycle
       @runners = []
       @subscriptions_pinged_at = Time.at(0)
-      @force_lock = false
+      @force_lock = force_lock
     end
 
     # Locks all Subscriptions behind the current SubscriptionsSet
@@ -59,6 +59,11 @@ module PgEventstore
     # locked by the new SubscriptionsSet.
     # @return [void]
     def force_lock!
+      message = <<~TEXT
+        Usage of #force_lock! is deprecated and will be removed in v2. Please pass :force_lock keyword argument when \
+        initializing SubscriptionsManager. Example: PgEventstore.subscriptions_manager(force_lock: true)
+      TEXT
+      Utils.deprecation_warning(message)
       @force_lock = true
     end