pg_eventstore 0.2.6 → 0.4.0

data/lib/pg_eventstore/queries/subscriptions_set_command_queries.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class SubscriptionsSetCommandQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param subscriptions_set_id [Integer]
+    # @param command_name [String]
+    # @return [Hash, nil]
+    def find_by(subscriptions_set_id:, command_name:)
+      sql_builder =
+        SQLBuilder.new.
+          select('*').
+          from('subscriptions_set_commands').
+          where('subscriptions_set_id = ? AND name = ?', subscriptions_set_id, command_name)
+      pg_result = connection.with do |conn|
+        conn.exec_params(*sql_builder.to_exec_params)
+      end
+      return if pg_result.ntuples.zero?
+
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @param subscriptions_set_id [Integer]
+    # @param command_name [String]
+    # @return [Hash]
+    def create_by(subscriptions_set_id:, command_name:)
+      sql = <<~SQL
+        INSERT INTO subscriptions_set_commands (name, subscriptions_set_id) 
+          VALUES ($1, $2)
+          RETURNING *
+      SQL
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, [command_name, subscriptions_set_id])
+      end
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @param subscriptions_set_id [Integer]
+    # @return [Array<Hash>]
+    def find_commands(subscriptions_set_id)
+      sql_builder =
+        SQLBuilder.new.select('*').
+          from('subscriptions_set_commands').
+          where("subscriptions_set_id = ?", subscriptions_set_id).
+          order('id ASC')
+      pg_result = connection.with do |conn|
+        conn.exec_params(*sql_builder.to_exec_params)
+      end
+      pg_result.to_a.map(&method(:deserialize))
+    end
+
+    # @param id [Integer]
+    # @return [void]
+    def delete(id)
+      connection.with do |conn|
+        conn.exec_params('DELETE FROM subscriptions_set_commands WHERE id = $1', [id])
+      end
+    end
+
+    private
+
+    # @param hash [Hash]
+    # @return [Hash]
+    def deserialize(hash)
+      hash.transform_keys(&:to_sym)
+    end
+  end
+end

data/lib/pg_eventstore/queries/subscriptions_set_queries.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class SubscriptionsSetQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param attrs [Hash]
+    # @return [Array<Hash>]
+    def find_all(attrs)
+      builder = SQLBuilder.new.select('*').from('subscriptions_set')
+      attrs.each do |attr, val|
+        builder.where("#{attr} = ?", val)
+      end
+
+      pg_result = connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end
+      pg_result.to_a.map(&method(:deserialize))
+    end
+
+    # The same as #find_all, but returns first result
+    # @return [Hash, nil]
+    def find_by(...)
+      find_all(...).first
+    end
+
+    # @param id [String] UUIDv4
+    # @return [Hash]
+    # @raise [PgEventstore::RecordNotFound]
+    def find!(id)
+      find_by(id: id) || raise(RecordNotFound.new("subscriptions_set", id))
+    end
+
+    # @param attrs [Hash]
+    # @return [Hash]
+    def create(attrs)
+      sql = <<~SQL
+        INSERT INTO subscriptions_set (#{attrs.keys.join(', ')}) 
+          VALUES (#{Utils.positional_vars(attrs.values)}) 
+          RETURNING *
+      SQL
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, attrs.values)
+      end
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @param id [String] UUIDv4
+    # @param attrs [Hash]
+    def update(id, attrs)
+      attrs = { updated_at: Time.now.utc }.merge(attrs)
+      attrs_sql = attrs.keys.map.with_index(1) do |attr, index|
+        "#{attr} = $#{index}"
+      end.join(', ')
+      sql = <<~SQL
+        UPDATE subscriptions_set SET #{attrs_sql} WHERE id = $#{attrs.keys.size + 1} RETURNING *
+      SQL
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, [*attrs.values, id])
+      end
+      raise(RecordNotFound.new("subscriptions_set", id)) if pg_result.ntuples.zero?
+
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @return id [Integer]
+    # @return [void]
+    def delete(id)
+      connection.with do |conn|
+        conn.exec_params('DELETE FROM subscriptions_set WHERE id = $1', [id])
+      end
+    end
+
+    private
+
+    # @param hash [Hash]
+    # @return [Hash]
+    def deserialize(hash)
+      hash.transform_keys(&:to_sym)
+    end
+  end
+end

data/lib/pg_eventstore/queries.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'sql_builder'
+require_relative 'query_builders/events_filtering_query'
 require_relative 'queries/transaction_queries'
 require_relative 'queries/event_queries'
 require_relative 'queries/stream_queries'
 require_relative 'queries/event_type_queries'
+require_relative 'queries/subscription_queries'
+require_relative 'queries/subscriptions_set_queries'
+require_relative 'queries/subscription_command_queries'
+require_relative 'queries/subscriptions_set_command_queries'
 
 module PgEventstore
   # @!visibility private

data/lib/pg_eventstore/query_builders/events_filtering_query.rb

@@ -5,7 +5,7 @@ module PgEventstore
     # @!visibility private
     class EventsFiltering
       DEFAULT_OFFSET = 0
-      DEFAULT_LIMIT = 1000
+      DEFAULT_LIMIT = 1_000
       SQL_DIRECTIONS = {
         'asc' => 'ASC',
         'desc' => 'DESC',
@@ -16,8 +16,15 @@ module PgEventstore
       }.tap do |directions|
         directions.default = 'ASC'
       end.freeze
+      SUBSCRIPTIONS_OPTIONS = %i[from_position resolve_link_tos filter max_count].freeze
 
       class << self
+        # @param options [Hash]
+        # @return [PgEventstore::QueryBuilders::EventsFiltering]
+        def subscriptions_events_filtering(options)
+          all_stream_filtering(options.slice(*SUBSCRIPTIONS_OPTIONS))
+        end
+
         # @param options [Hash]
         # @param offset [Integer]
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
@@ -96,7 +103,7 @@ module PgEventstore
         sql = event_type_ids.size.times.map do
           "?"
         end.join(", ")
-        @sql_builder.where("event_types.id IN (#{sql})", *event_type_ids)
+        @sql_builder.where("events.event_type_id IN (#{sql})", *event_type_ids)
       end
 
       # @param revision [Integer, nil]
@@ -157,6 +164,11 @@ module PgEventstore
           join("LEFT JOIN events original_events ON original_events.id = events.link_id")
       end
 
+      # @return [PgEventstore::SQLBuilder]
+      def to_sql_builder
+        @sql_builder
+      end
+
       # @return [Array]
       def to_exec_params
         @sql_builder.to_exec_params

data/lib/pg_eventstore/sql_builder.rb

@@ -13,6 +13,8 @@ module PgEventstore
       @limit_value = nil
       @offset_value = nil
       @positional_values = []
+      @positional_values_size = 0
+      @union_values = []
     end
 
     # @param sql [String]
@@ -32,8 +34,7 @@ module PgEventstore
     # @param arguments [Array] positional values
     # @return self
     def where(sql, *arguments)
-      sql = extract_positional_args(sql, *arguments)
-      @where_values['AND'].push("(#{sql})")
+      @where_values['AND'].push([sql, arguments])
       self
     end
 
@@ -41,8 +42,7 @@ module PgEventstore
     # @param arguments [Object] positional values
     # @return self
     def where_or(sql, *arguments)
-      sql = extract_positional_args(sql, *arguments)
-      @where_values['OR'].push("(#{sql})")
+      @where_values['OR'].push([sql, arguments])
       self
     end
 
@@ -57,7 +57,7 @@ module PgEventstore
     # @param arguments [Object]
     # @return self
     def join(sql, *arguments)
-      @join_values.push(extract_positional_args(sql, *arguments))
+      @join_values.push([sql, arguments])
       self
     end
 
@@ -82,7 +82,34 @@ module PgEventstore
       self
     end
 
+    # @param another_builder [PgEventstore::SQLBuilder]
+    # @return [self]
+    def union(another_builder)
+      @union_values.push(another_builder)
+      self
+    end
+
     def to_exec_params
+      return [single_query_sql, @positional_values] if @union_values.empty?
+
+      [union_query_sql, @positional_values]
+    end
+
+    protected
+
+    # @return [Array<Object>] sql positional values
+    def positional_values
+      @positional_values
+    end
+
+    def positional_values_size=(val)
+      @positional_values_size = val
+    end
+
+    private
+
+    # @return [String]
+    def single_query_sql
       where_sql = [where_sql('OR'), where_sql('AND')].reject(&:empty?).map { |sql| "(#{sql})" }.join(' AND ')
       sql = "SELECT #{select_sql} FROM #{@from_value}"
       sql += " #{join_sql}" unless @join_values.empty?
@@ -90,10 +117,22 @@ module PgEventstore
       sql += " ORDER BY #{order_sql}" unless @order_values.empty?
       sql += " LIMIT #{@limit_value}" if @limit_value
       sql += " OFFSET #{@offset_value}" if @offset_value
-      [sql, @positional_values]
+      sql
     end
 
-    private
+    # @return [String]
+    def union_query_sql
+      sql = single_query_sql
+      union_parts = ["(#{sql})"]
+      union_parts += @union_values.map do |builder|
+        builder.positional_values_size = @positional_values_size
+        builder_sql, values = builder.to_exec_params
+        @positional_values.push(*values)
+        @positional_values_size += values.size
+        "(#{builder_sql})"
+      end
+      union_parts.join(' UNION ALL ')
+    end
 
     # @return [String]
     def select_sql
@@ -103,12 +142,14 @@ module PgEventstore
     # @param join_pattern [String] "OR"/"AND"
     # @return [String]
     def where_sql(join_pattern)
-      @where_values[join_pattern].join(" #{join_pattern} ")
+      @where_values[join_pattern].map do |sql, args|
+        "(#{extract_positional_args(sql, *args)})"
+      end.join(" #{join_pattern} ")
     end
 
     # @return [String]
     def join_sql
-      @join_values.join(" ")
+      @join_values.map { |sql, args| extract_positional_args(sql, *args) }.join(" ")
     end
 
     # @return [String]
@@ -116,10 +157,13 @@ module PgEventstore
       @order_values.join(', ')
     end
 
+    # Replaces "?" signs in the given string with positional variables and memorize positional values they refer to.
+    # @return [String]
     def extract_positional_args(sql, *arguments)
       sql.gsub("?").each_with_index do |_, index|
         @positional_values.push(arguments[index])
-        "$#{@positional_values.size}"
+        @positional_values_size += 1
+        "$#{@positional_values_size}"
       end
     end
   end

data/lib/pg_eventstore/subscriptions/basic_runner.rb

@@ -0,0 +1,220 @@
+# 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:
+  # - :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.
+  # - :after_runner_stopped. Happens after runner's state got switched from "running"/"dead" to "stopped" and runner's
+  #   thread is terminated.
+  # - :before_runner_restored. Happens before runner's state gets switched from "dead" to "running" and runner's
+  #   thread is started.
+  # - :process_async. Happens each @run_interval seconds within runner's thread.
+  # - :after_runner_died. Happens when runner's state switches to "dead" because of exception inside runner's thread.
+  #   Callback function must be able to accept one argument - the exception which caused the runner to die will be
+  #   passed.
+  # - :change_state. It happens each time the runner changes the state. Callback function must be able to accept one
+  #   argument - current state will be passed.
+  #
+  # Example of BasicRunner usage:
+  #   class MyAwesomeRunner
+  #     extend Forwardable
+  #
+  #     def_delegators :@basic_runner, :start, :stop, :wait_for_finish, :stop_async, :restore
+  #
+  #     def initialize
+  #       @basic_runner = PgEventstore::BasicRunner.new(1, 2)
+  #       @jobs_performed = 0
+  #       attach_runner_callbacks
+  #     end
+  #
+  #     private
+  #
+  #     def attach_runner_callbacks
+  #       @basic_runner.define_callback(:change_state, :after, method(:state_changed))
+  #       @basic_runner.define_callback(:process_async, :before, method(:process_action))
+  #       @basic_runner.define_callback(:process_async, :after, method(:count_jobs))
+  #       @basic_runner.define_callback(:before_runner_started, :before, method(:before_runner_started))
+  #       @basic_runner.define_callback(:after_runner_stopped, :before, method(:after_runner_stopped))
+  #       @basic_runner.define_callback(:after_runner_died, :before, method(:after_runner_died))
+  #     end
+  #
+  #     def process_action
+  #       raise "What's the point? I can not handle this any more!" if @jobs_performed >= 3
+  #       puts "Doing some heavy lifting job"
+  #       sleep 2 # Simulate long running job
+  #     end
+  #
+  #     def count_jobs
+  #       @jobs_performed += 1
+  #     end
+  #
+  #     # @param state [String]
+  #     def state_changed(state)
+  #       puts "New state is #{state.inspect}"
+  #     end
+  #
+  #     def before_runner_started
+  #       puts "Doing some preparations..."
+  #     end
+  #
+  #     def after_runner_stopped
+  #       puts "You job is not processing any more. Total jobs performed: #{@jobs_performed}. Bye-bye!"
+  #     end
+  #
+  #     def after_runner_died(error)
+  #       puts "Error occurred: #{error.inspect}"
+  #     end
+  #   end
+  #
+  #   runner = MyAwesomeRunner.new
+  #   runner.start # to start your background runner to process the job, defined by #process_action method
+  #   runner.stop # to stop the runner
+  #
+  # See {PgEventstore::RunnerState} for the list of available states
+  # See {PgEventstore::CallbacksExtension} and {PgEventstore::Callbacks} for more info about how to use callbacks
+  class BasicRunner
+    extend Forwardable
+    include Extensions::CallbacksExtension
+
+    def_delegators :@state, :initial?, :running?, :halting?, :stopped?, :dead?
+
+    # @param run_interval [Integer, Float] seconds. Determines how often to run async task. Async task is determined by
+    #   :after_runner_stopped callback
+    # @param async_shutdown_time [Integer, Float] seconds. Determines how long to wait for the async shutdown to wait
+    #   for the runner to finish.
+    def initialize(run_interval, async_shutdown_time)
+      @run_interval = run_interval
+      @async_shutdown_time = async_shutdown_time
+      @state = RunnerState.new
+      @mutex = Thread::Mutex.new
+      delegate_change_state_cbx
+    end
+
+    # Start asynchronous runner. If the runner is dead - please use #restore to restart it.
+    # @return [self]
+    def start
+      synchronize do
+        return self unless @state.initial? || @state.stopped?
+
+        callbacks.run_callbacks(:before_runner_started)
+        _start
+      end
+      self
+    end
+
+    # Stop asynchronous runner. This operation is immediate and it won't be waiting for current job to finish - it will
+    # instantly halt it. If you care about the result of your async job - use #stop_async instead.
+    # @return [self]
+    def stop
+      synchronize do
+        return self unless @state.running? || @state.dead?
+
+        @runner&.exit
+        @runner = nil
+        @state.stopped!
+        callbacks.run_callbacks(:after_runner_stopped)
+      end
+      self
+    end
+
+    # Asynchronously stop asynchronous runner. This operation spawns another thread to gracefully stop the runner. It
+    # will wait up to @async_shutdown_time seconds before force-stopping the runner.
+    # @return [self]
+    def stop_async
+      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
+
+              unless @runner&.alive?
+                @state.stopped!
+                @runner = nil
+                callbacks.run_callbacks(:after_runner_stopped)
+                halt = true
+              end
+            end
+            break if halt
+            sleep 0.1
+          end
+        end
+        self
+      end
+    end
+
+    # Restores the runner after its death.
+    # @return [self]
+    def restore
+      synchronize do
+        return self unless @state.dead?
+
+        callbacks.run_callbacks(:before_runner_restored)
+        _start
+      end
+      self
+    end
+
+    # Wait until the runner switches the state to either "stopped" or "dead". This operation is synchronous.
+    # @return [self]
+    def wait_for_finish
+      loop do
+        continue = synchronize do
+          @state.halting? || @state.running?
+        end
+        break unless continue
+
+        sleep 0.1
+      end
+      self
+    end
+
+    # @return [String]
+    def state
+      @state.to_s
+    end
+
+    private
+
+    def synchronize
+      @mutex.synchronize { yield }
+    end
+
+    # @return [void]
+    def _start
+      @state.running!
+      @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?
+
+          @state.dead!
+          callbacks.run_callbacks(:after_runner_died, error)
+        end
+      end
+    end
+
+    # Delegates :change_state action to the runner
+    def delegate_change_state_cbx
+      @state.define_callback(:change_state, :before, method(:change_state))
+    end
+
+    def change_state(...)
+      callbacks.run_callbacks(:change_state, ...)
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module CommandHandlers
+    class SubscriptionFeederCommands
+      AVAILABLE_COMMANDS = %w[StopAll StartAll].freeze
+
+      # @param config_name [Symbol]
+      # @param subscription_feeder [PgEventstore::SubscriptionFeeder]
+      def initialize(config_name, subscription_feeder)
+        @config_name = config_name
+        @subscription_feeder = subscription_feeder
+      end
+
+      # Look up commands for the given SubscriptionFeeder and execute them
+      # @return [void]
+      def process
+        queries.find_commands(@subscription_feeder.id).each do |command|
+          unless AVAILABLE_COMMANDS.include?(command[:name])
+            PgEventstore.logger&.warn(
+              "#{self.class.name}: Don't know how to handle #{command[:name].inspect}. Details: #{command.inspect}."
+            )
+            next
+          end
+          send(Utils.underscore_str(command[:name]))
+        ensure
+          queries.delete(command[:id])
+        end
+      end
+
+      private
+
+      # @return [PgEventstore::SubscriptionsSetCommandQueries]
+      def queries
+        SubscriptionsSetCommandQueries.new(connection)
+      end
+
+      # @return [PgEventstore::Connection]
+      def connection
+        PgEventstore.connection(@config_name)
+      end
+
+      def stop_all
+        @subscription_feeder.stop_all
+      end
+
+      def start_all
+        @subscription_feeder.start_all
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module CommandHandlers
+    class SubscriptionRunnersCommands
+      AVAILABLE_COMMANDS = %w[StopRunner RestoreRunner StartRunner].freeze
+
+      # @param config_name [Symbol]
+      # @param runners [Array<PgEventstore::SubscriptionRunner>]
+      def initialize(config_name, runners)
+        @config_name = config_name
+        @runners = runners
+      end
+
+      # Look up commands for all given SubscriptionRunner-s and execute them
+      # @return [void]
+      def process
+        queries.find_commands(@runners.map(&:id)).each do |command|
+          unless AVAILABLE_COMMANDS.include?(command[:name])
+            PgEventstore.logger&.warn(
+              "#{self.class.name}: Don't know how to handle #{command[:name].inspect}. Details: #{command.inspect}."
+            )
+            next
+          end
+          send(Utils.underscore_str(command[:name]), command[:subscription_id])
+        ensure
+          queries.delete(command[:id])
+        end
+      end
+
+      private
+
+      # @return [PgEventstore::SubscriptionCommandQueries]
+      def queries
+        SubscriptionCommandQueries.new(connection)
+      end
+
+      # @return [PgEventstore::Connection]
+      def connection
+        PgEventstore.connection(@config_name)
+      end
+
+      # @param subscription_id [Integer]
+      # @return [PgEventstore::SubscriptionRunner, nil]
+      def find_subscription_runner(subscription_id)
+        @runners.find { |runner| runner.id == subscription_id }
+      end
+
+      # @param subscription_id [Integer]
+      # @return [void]
+      def start_runner(subscription_id)
+        find_subscription_runner(subscription_id)&.start
+      end
+
+      # @param subscription_id [Integer]
+      # @return [void]
+      def restore_runner(subscription_id)
+        find_subscription_runner(subscription_id)&.restore
+      end
+
+      # @param subscription_id [Integer]
+      # @return [void]
+      def stop_runner(subscription_id)
+        find_subscription_runner(subscription_id)&.stop_async
+      end
+    end
+  end
+end