pg_eventstore 1.5.0 → 1.7.0

data/lib/pg_eventstore/cli/parsers/base_parser.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module CLI
+    module Parsers
+      class BaseParser
+        class << self
+          # @return [String]
+          def banner
+            raise NotImplementedError
+          end
+        end
+
+        attr_reader :args, :options
+
+        # @param args [Array<String>]
+        # @param options [PgEventstore::CLI::ParserOptions::BaseOptions]
+        def initialize(args, options)
+          @args = args
+          @options = options
+          @parser = ::OptionParser.new(self.class.banner)
+        end
+
+        # @return [Array<Array<String>, PgEventstore::CLI::ParserOptions::BaseOptions>] list of commands and parsed
+        #   options
+        def parse
+          @options.attach_parser_handlers(@parser)
+          [@parser.parse(args), @options]
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/cli/parsers/default_parser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module CLI
+    module Parsers
+      class DefaultParser < BaseParser
+        class << self
+          # @return [String]
+          def banner
+            <<~TEXT
+            Usage: pg-eventstore [options]
+                   pg-eventstore [command]
+        
+              Commands:
+                subscriptions     Start, stop subscriptions
+  
+              Options:
+          TEXT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/cli/parsers/subscription_parser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module CLI
+    module Parsers
+      class SubscriptionParser < BaseParser
+        class << self
+          # @return [String]
+          def banner
+            <<~TEXT
+              Usage: pg-eventstore subscriptions [command] [options]
+                
+                Commands:
+                  start     Start subscriptions. Example: pg-eventstore subscriptions start -r lib/my_subscriptions.rb 
+                  stop      Stop subscriptions. Example: pg-eventstore subscriptions stop
+
+                Options:
+            TEXT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/cli/parsers.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'parsers/base_parser'
+require_relative 'parsers/default_parser'
+require_relative 'parsers/subscription_parser'

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/commands/read.rb

@@ -15,7 +15,7 @@ module PgEventstore
       # @return [Array<PgEventstore::Event>]
       # @raise [PgEventstore::StreamNotFoundError]
       def call(stream, options: {})
-        queries.events.stream_revision(stream) || raise(StreamNotFoundError, stream) unless stream.all_stream?
+        queries.events.stream_revision(stream) || raise(StreamNotFoundError, stream) unless stream.system?
 
         queries.events.stream_events(stream, options)
       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/queries/event_queries.rb

@@ -70,7 +70,7 @@ module PgEventstore
     # @param options [Hash]
     # @return [Array<PgEventstore::Event>]
     def stream_events(stream, options)
-      exec_params = events_filtering(stream, options).to_exec_params
+      exec_params = QueryBuilders::EventsFiltering.events_filtering(stream, options).to_exec_params
       raw_events = connection.with do |conn|
         conn.exec_params(*exec_params)
       end.to_a
@@ -128,15 +128,6 @@ module PgEventstore
       [sql_rows_for_insert, values]
     end
 
-    # @param stream [PgEventstore::Stream]
-    # @param options [Hash]
-    # @return [PgEventstore::EventsFiltering]
-    def events_filtering(stream, options)
-      return QueryBuilders::EventsFiltering.all_stream_filtering(options) if stream.all_stream?
-
-      QueryBuilders::EventsFiltering.specific_stream_filtering(stream, options)
-    end
-
     # @return [PgEventstore::LinksResolver]
     def links_resolver
       LinksResolver.new(connection)

data/lib/pg_eventstore/query_builders/events_filtering.rb

@@ -21,6 +21,18 @@ module PgEventstore
       SUBSCRIPTIONS_OPTIONS = %i[from_position resolve_link_tos filter max_count].freeze
 
       class << self
+        # @param stream [PgEventstore::Stream]
+        # @param options [Hash]
+        # @return [PgEventstore::EventsFiltering]
+        def events_filtering(stream, options)
+          return all_stream_filtering(options) if stream.all_stream?
+          if stream.system? && Stream::KNOWN_SYSTEM_STREAMS.include?(stream.context)
+            return system_stream_filtering(stream, options)
+          end
+
+          specific_stream_filtering(stream, options)
+        end
+
         # @param options [Hash]
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
         def subscriptions_events_filtering(options)
@@ -54,6 +66,15 @@ module PgEventstore
           event_filter.add_stream_direction(options[:direction])
           event_filter
         end
+
+        # @param stream [PgEventstore::Stream] system stream
+        # @param options [Hash]
+        # @return [PgEventstore::QueryBuilders::EventsFiltering]
+        def system_stream_filtering(stream, options)
+          all_stream_filtering(options).tap do |event_filter|
+            event_filter.set_source(stream.context)
+          end
+        end
       end
 
       def initialize
@@ -139,6 +160,12 @@ module PgEventstore
         @sql_builder.to_exec_params
       end
 
+      # @param table_name [String] system stream view name
+      # @return [void]
+      def set_source(table_name)
+        @sql_builder.from(%{ "#{PG::Connection.escape(table_name)}" events })
+      end
+
       private
 
       # @param stream_attrs [Hash]

data/lib/pg_eventstore/rspec/has_option_matcher.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 # This matcher is defined to test options which are defined by using
-# EventStoreClient::Extensions::OptionsExtension option. Example:
+# PgEventstore::Extensions::OptionsExtension option. Example:
 # Let's say you have next class
 # class SomeClass
 #   include PgEventstore::Extensions::OptionsExtension
 #
-#   option(:some_opt) { '1' }
+#   option(:some_opt, metadata: { foo: :bar }) { '1' }
 # end
 #
-# To test that its instance has the proper option with the proper default value you can use this
+# To test that its instance has the proper option with the proper default value and proper metadata you can use this
 # matcher:
 # RSpec.describe SomeClass do
 #   subject { described_class.new }
@@ -17,53 +17,50 @@
 #   # Check that :some_opt is present
 #   it { is_expected.to have_option(:some_opt) }
 #   # Check that :some_opt is present and has the correct default value
-#   it { is_expected.to have_option(:some_opt).with_default_value('1') }
-# end
-#
-# If you have more complex implementation of default value of your option - you should handle it
-# customly. For example:
-# class SomeClass
-#   include PgEventstore::Extensions::OptionsExtension
-#
-#   option(:some_opt) { calc_value }
-# end
-# You could test it like so:
-# RSpec.described SomeClass do
-#   let(:instance) { described_class.new }
-#
-#   describe ':some_opt default value' do
-#     subject { instance.some_opt }
-#
-#     let(:value) { 'some val' }
-#
-#     before do
-#       allow(instance).to receive(:calc_value).and_return(value)
-#     end
-#
-#     it { is_expected.to eq(value) }
-#   end
+#   it { is_expected.to have_option(:some_opt).with_default_value('1').with_metadata(foo: :bar) }
 # 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 +80,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/stream.rb

@@ -8,6 +8,8 @@ module PgEventstore
     SYSTEM_STREAM_PREFIX = '$'
     # @return [Integer]
     NON_EXISTING_STREAM_REVISION = -1
+    # @return [Array<String>]
+    KNOWN_SYSTEM_STREAMS = %w[$streams].freeze
 
     class << self
       # Produces "all" stream instance. "all" stream does not represent any specific stream. Instead, it indicates that
@@ -18,6 +20,12 @@ module PgEventstore
           stream.instance_variable_set(:@all_stream, true)
         end
       end
+
+      # @param name [String]
+      # @return [PgEventstore::Stream]
+      def system_stream(name)
+        new(context: name, stream_name: '', stream_id: '')
+      end
     end
 
     # @!attribute context

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?