event_sourcery 0.13.0

data/lib/event_sourcery/event_processing/esp_process.rb

@@ -0,0 +1,41 @@
+module EventSourcery
+  module EventProcessing
+    class ESPProcess
+      def initialize(event_processor:,
+                     event_source:,
+                     subscription_master: EventStore::SignalHandlingSubscriptionMaster.new)
+        @event_processor = event_processor
+        @event_source = event_source
+        @subscription_master = subscription_master
+      end
+
+      def start
+        name_process
+        error_handler.with_error_handling do
+          EventSourcery.logger.info("Starting #{processor_name}")
+          subscribe_to_event_stream
+          EventSourcery.logger.info("Stopping #{@event_processor.processor_name}")
+        end
+      end
+
+      private
+
+      def processor_name
+        @event_processor.processor_name.to_s
+      end
+
+      def error_handler
+        @error_handler ||= EventSourcery.config.error_handler_class.new(processor_name: processor_name)
+      end
+
+      def name_process
+        Process.setproctitle(@event_processor.class.name)
+      end
+
+      def subscribe_to_event_stream
+        @event_processor.subscribe_to(@event_source,
+                                      subscription_master: @subscription_master)
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_processing/esp_runner.rb

@@ -0,0 +1,105 @@
+module EventSourcery
+  module EventProcessing
+    # NOTE: databases should be disconnected before running this
+    # EventSourcery.config.postgres.event_store_database.disconnect
+    class ESPRunner
+      def initialize(event_processors:,
+                     event_source:,
+                     max_seconds_for_processes_to_terminate: 30,
+                     shutdown_requested: false)
+        @event_processors = event_processors
+        @event_source = event_source
+        @pids = []
+        @max_seconds_for_processes_to_terminate = max_seconds_for_processes_to_terminate
+        @shutdown_requested = shutdown_requested
+        @exit_status = true
+      end
+
+      def start!
+        with_logging do
+          start_processes
+          listen_for_shutdown_signals
+          wait_till_shutdown_requested
+          record_terminated_processes
+          terminate_remaining_processes
+          until all_processes_terminated? || waited_long_enough?
+            record_terminated_processes
+          end
+          kill_remaining_processes
+          record_terminated_processes until all_processes_terminated?
+        end
+        exit_indicating_status_of_processes
+      end
+
+      private
+
+      def with_logging
+        EventSourcery.logger.info { 'Forking ESP processes' }
+        yield
+        EventSourcery.logger.info { 'ESP processes shutdown' }
+      end
+
+      def start_processes
+        @event_processors.each(&method(:start_process))
+      end
+
+      def start_process(event_processor)
+        process = ESPProcess.new(
+          event_processor: event_processor,
+          event_source: @event_source
+        )
+        @pids << Process.fork { process.start }
+      end
+
+      def listen_for_shutdown_signals
+        %i(TERM INT).each do |signal|
+          Signal.trap(signal) { shutdown }
+        end
+      end
+
+      def shutdown
+        @shutdown_requested = true
+      end
+
+      def wait_till_shutdown_requested
+        sleep(1) until @shutdown_requested
+      end
+
+      def terminate_remaining_processes
+        send_signal_to_remaining_processes(:TERM)
+      end
+
+      def kill_remaining_processes
+        send_signal_to_remaining_processes(:KILL)
+      end
+
+      def send_signal_to_remaining_processes(signal)
+        Process.kill(signal, *@pids) unless all_processes_terminated?
+      rescue Errno::ESRCH
+        record_terminated_processes
+        retry
+      end
+
+      def record_terminated_processes
+        until all_processes_terminated? ||
+              ((pid, status) = Process.wait2(-1, Process::WNOHANG)).nil?
+          @pids.delete(pid)
+          @exit_status &&= status.success?
+        end
+      end
+
+      def all_processes_terminated?
+        @pids.empty?
+      end
+
+      def waited_long_enough?
+        @timeout ||= Time.now + @max_seconds_for_processes_to_terminate
+        Time.now >= @timeout
+      end
+
+      def exit_indicating_status_of_processes
+        Process.exit(@exit_status)
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_processing/event_stream_processor.rb

@@ -0,0 +1,125 @@
+module EventSourcery
+  module EventProcessing
+    module EventStreamProcessor
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
+        base.prepend(ProcessHandler)
+        EventSourcery.event_stream_processor_registry.register(base)
+        base.class_eval do
+          @event_handlers = Hash.new { |hash, key| hash[key] = [] }
+        end
+      end
+
+      module InstanceMethods
+        def initialize(tracker:)
+          @tracker = tracker
+        end
+      end
+
+      module ProcessHandler
+        def process(event)
+          @_event = event
+          handlers = self.class.event_handlers[event.type]
+          if handlers.any?
+            handlers.each do |handler|
+              instance_exec(event, &handler)
+            end
+          elsif self.class.processes?(event.type)
+            if defined?(super)
+              super(event)
+            else
+              raise UnableToProcessEventError, "I don't know how to process '#{event.type}' events."
+            end
+          end
+          @_event = nil
+        rescue
+          raise EventProcessingError.new(event)
+        end
+      end
+
+      module ClassMethods
+        attr_reader :processes_event_types, :event_handlers
+
+        def processes_events(*event_types)
+          @processes_event_types = Array(@processes_event_types) | event_types.map(&:to_s)
+        end
+
+        def processes_all_events
+          define_singleton_method :processes? do |_|
+            true
+          end
+        end
+
+        def processes?(event_type)
+          processes_event_types &&
+            processes_event_types.include?(event_type.to_s)
+        end
+
+        def processor_name(name = nil)
+          if name
+            @processor_name = name
+          else
+            (defined?(@processor_name) && @processor_name) || self.name
+          end
+        end
+
+        def process(*event_classes, &block)
+          event_classes.each do |event_class|
+            processes_events event_class.type
+            @event_handlers[event_class.type] << block
+          end
+        end
+      end
+
+      def processes_event_types
+        self.class.processes_event_types
+      end
+
+      def setup
+        tracker.setup(processor_name)
+      end
+
+      def reset
+        tracker.reset_last_processed_event_id(processor_name)
+      end
+
+      def last_processed_event_id
+        tracker.last_processed_event_id(processor_name)
+      end
+
+      def processor_name
+        self.class.processor_name
+      end
+
+      def processes?(event_type)
+        self.class.processes?(event_type)
+      end
+
+      def subscribe_to(event_source, subscription_master: EventStore::SignalHandlingSubscriptionMaster.new)
+        setup
+        event_source.subscribe(from_id: last_processed_event_id + 1,
+                              event_types: processes_event_types,
+                              subscription_master: subscription_master) do |events|
+          process_events(events, subscription_master)
+        end
+      end
+
+      attr_accessor :tracker
+
+      private
+
+      attr_reader :_event
+
+      def process_events(events, subscription_master)
+        events.each do |event|
+          subscription_master.shutdown_if_requested
+          process(event)
+          tracker.processed_event(processor_name, event.id)
+          EventSourcery.logger.debug { "[#{processor_name}] Processed event: #{event.inspect}" }
+        end
+        EventSourcery.logger.info { "[#{processor_name}] Processed up to event id: #{events.last.id}" }
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_processing/event_stream_processor_registry.rb

@@ -0,0 +1,29 @@
+module EventSourcery
+  module EventProcessing
+    class EventStreamProcessorRegistry
+      def initialize
+        @processors = []
+      end
+
+      def register(klass)
+        @processors << klass
+      end
+
+      def find(processor_name)
+        @processors.find do |processor|
+          processor.processor_name == processor_name
+        end
+      end
+
+      def by_type(constant)
+        @processors.select do |processor|
+          processor.included_modules.include?(constant)
+        end
+      end
+
+      def all
+        @processors
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_store/each_by_range.rb

@@ -0,0 +1,25 @@
+module EventSourcery
+  module EventStore
+    module EachByRange
+      def each_by_range(from_event_id, to_event_id, event_types: nil)
+        caught_up = false
+        no_events_left = false
+        event_id = from_event_id
+        begin
+          events = get_next_from(event_id, event_types: event_types)
+          no_events_left = true if events.empty?
+          events.each do |event|
+            yield event
+            if event.id == to_event_id
+              caught_up = true
+              break
+            end
+          end
+          unless no_events_left
+            event_id = events.last.id + 1
+          end
+        end while !caught_up && !no_events_left
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_store/event_builder.rb

@@ -0,0 +1,19 @@
+module EventSourcery
+  module EventStore
+    class EventBuilder
+      def initialize(event_type_serializer:)
+        @event_type_serializer = event_type_serializer
+      end
+
+      def build(event_data)
+        type = event_data.fetch(:type)
+        klass = event_type_serializer.deserialize(type)
+        klass.new(event_data)
+      end
+
+      private
+
+      attr_reader :event_type_serializer
+    end
+  end
+end

data/lib/event_sourcery/event_store/event_sink.rb

@@ -0,0 +1,18 @@
+require 'forwardable'
+
+module EventSourcery
+  module EventStore
+    class EventSink
+      def initialize(event_store)
+        @event_store = event_store
+      end
+
+      extend Forwardable
+      def_delegators :event_store, :sink
+
+      private
+
+      attr_reader :event_store
+    end
+  end
+end

data/lib/event_sourcery/event_store/event_source.rb

@@ -0,0 +1,21 @@
+module EventSourcery
+  module EventStore
+    class EventSource
+      def initialize(event_store)
+        @event_store = event_store
+      end
+
+      extend Forwardable
+      def_delegators :event_store,
+                     :get_next_from,
+                     :latest_event_id,
+                     :get_events_for_aggregate_id,
+                     :each_by_range,
+                     :subscribe
+
+      private
+
+      attr_reader :event_store
+    end
+  end
+end

data/lib/event_sourcery/event_store/event_type_serializers/class_name.rb

@@ -0,0 +1,19 @@
+module EventSourcery
+  module EventStore
+    module EventTypeSerializers
+      # Stores event types by their class name and falls back to the generic
+      # Event class if the constant is not found
+      class ClassName
+        def serialize(event_class)
+          event_class.name
+        end
+
+        def deserialize(event_type)
+          Object.const_get(event_type)
+        rescue NameError
+          Event
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_store/event_type_serializers/legacy.rb

@@ -0,0 +1,17 @@
+module EventSourcery
+  module EventStore
+    module EventTypeSerializers
+      # To support legacy implementations.  Type is provided when initializing
+      # the event, not derived from the class constant
+      class Legacy
+        def serialize(event_class)
+          nil
+        end
+
+        def deserialize(event_type)
+          Event
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_store/event_type_serializers/underscored.rb

@@ -0,0 +1,68 @@
+module EventSourcery
+  module EventStore
+    module EventTypeSerializers
+      # Stores event types by the underscored version of the class name and
+      # falls back to the generic Event class if the constant is not found
+      #
+      # Replace inflector with ActiveSupport like this:
+      # EventSourcery::EventStore::EventTypeSerializers::Underscored.inflector = ActiveSupport::Inflector
+      class Underscored
+        class Inflector
+          # Inflection methods are taken from active support 3.2
+          # https://github.com/rails/rails/blob/3-2-stable/activesupport/lib/active_support/inflector/methods.rb
+          def underscore(camel_cased_word)
+            word = camel_cased_word.to_s.dup
+            word.gsub!(/::/, '/')
+            word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+            word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+            word.tr!("-", "_")
+            word.downcase!
+            word
+          end
+
+          def camelize(term, uppercase_first_letter = true)
+            string = term.to_s
+            if uppercase_first_letter
+              string = string.sub(/^[a-z\d]*/) { capitalize($&) }
+            else
+              string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+            end
+            string.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{capitalize($2)}" }.gsub('/', '::')
+          end
+
+          private
+
+          def capitalize(lower_case_and_underscored_word)
+            result = lower_case_and_underscored_word.to_s.dup
+            result.gsub!(/_id$/, "")
+            result.gsub!(/_/, ' ')
+            result.gsub(/([a-z\d]*)/i) { |match|
+              "#{match.downcase}"
+            }.gsub(/^\w/) { $&.upcase }
+          end
+        end
+
+        class << self
+          attr_accessor :inflector
+        end
+        @inflector = Inflector.new
+
+        def serialize(event_class)
+          underscore_class_name(event_class.name)
+        end
+
+        def deserialize(event_type)
+          Object.const_get(self.class.inflector.camelize(event_type))
+        rescue NameError
+          Event
+        end
+
+        private
+
+        def underscore_class_name(class_name)
+          self.class.inflector.underscore(class_name)
+        end
+      end
+    end
+  end
+end