evil_events 0.2.0 → 0.3.0

data/lib/evil_events/core/events/notifier/builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::Notifier
+  # @api private
+  # @sicne 0.3.0
+  module Builder
+    class << self
+      # @raise EvilEvents::UnknownNotifierTypeError
+      # @return [Notifier::Abstract, Notifier::Sequential, Notifier::Worker]
+      #
+      # @api private
+      # @since 0.3.0
+      def build_notifier!
+        case EvilEvents::Core::Bootstrap[:config].notifier.type
+        when :sequential then build_sequential_notifier!
+        when :worker     then build_worker_notifier!
+        else
+          raise EvilEvents::UnknownNotifierTypeError
+        end
+      end
+
+      private
+
+      # @return [Notifier::Sequential]
+      #
+      # @api private
+      # @since 0.3.0
+      def build_sequential_notifier!
+        options = EvilEvents::Core::Bootstrap[:config].notifier.sequential.to_h
+        Sequential.new(**options)
+      end
+
+      # @return [Notifier::Worker]
+      #
+      # @api private
+      # @since 0.3.0
+      def build_worker_notifier!
+        options = EvilEvents::Core::Bootstrap[:config].notifier.worker.to_h
+        Worker.new(**options)
+      end
+    end
+  end
+end

data/lib/evil_events/core/events/notifier/logging.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.3.0
+module EvilEvents::Core::Events::Notifier::Logging
+  # @param event [EvilEvents::Core::Events::AbstractEvent]
+  # @param subscriber [EvilEvents::Core::Events::Subscriber]
+  # @return void
+  #
+  # @api private
+  # @since 0.3.0
+  def log_failure(event, subscriber)
+    log_activity(event, subscriber, :failed)
+  end
+
+  # @param event [EvilEvents::Core::Events::AbstractEvent]
+  # @param subscriber [EvilEvents::Core::Events::Subscriber]
+  # @return void
+  #
+  # @api private
+  # @since 0.3.0
+  def log_success(event, subscriber)
+    log_activity(event, subscriber, :successful)
+  end
+
+  private
+
+  # @param event [EvilEvents::Core::Events::AbstractEvent]
+  # @param subscriber [EvilEvents::Core::Events::Subscriber]
+  # @param status [String, Symbol]
+  # @return void
+  #
+  # @api private
+  # @since 0.3.0
+  def log_activity(event, subscriber, status)
+    activity = "EventProcessed(#{event.type})"
+    message  = "EVENT_ID: #{event.id} :: " \
+               "STATUS: #{status} :: " \
+               "SUBSCRIBER: #{subscriber.source_object}"
+
+    EvilEvents::Core::ActivityLogger.log(activity: activity, message: message)
+  end
+end

data/lib/evil_events/core/events/notifier/proxy.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.3.0
+class EvilEvents::Core::Events::Notifier::Proxy
+  # @since 0.3.0
+  extend Forwardable
+
+  # @since 0.3.0
+  def_delegators :notifier, :shutdown!, :restart!, :notify
+
+  # @return [Mutex]
+  #
+  # @api private
+  # @since 0.3.0
+  attr_reader :initialization_mutex
+
+  # @api private
+  # @since 0.3.0
+  def initialize
+    @initialization_mutex = Mutex.new
+  end
+
+  # @return [Abstract, Sequential, Worker]
+  #
+  # @api private
+  # @since 0.3.0
+  def notifier
+    initialization_mutex.synchronize do
+      @notifier ||= EvilEvents::Core::Events::Notifier::Builder.build_notifier!
+    end
+  end
+end

data/lib/evil_events/core/events/notifier/sequential.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::Notifier
+  # @api private
+  # @since 0.3.0
+  class Sequential < Abstract
+    # @since 0.3.0
+    include Logging
+
+    # @param manager [EvilEvents::Core::Events::Manager]
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @raise [EvilEvents::FailedNotifiedSubscribersError]
+    # @return void
+    #
+    # @api private
+    # @since 0.3.0
+    def notify(manager, event)
+      errors_stack = EvilEvents::FailedNotifiedSubscribersError.new
+
+      event.__call_before_hooks__
+
+      manager.subscribers.each do |subscriber|
+        begin
+          subscriber.notify(event)
+
+          log_success(event, subscriber)
+        rescue StandardError => error
+          event.__call_on_error_hooks__(error)
+
+          errors_stack << error
+
+          log_failure(event, subscriber)
+        end
+      end
+
+      event.__call_after_hooks__
+
+      raise errors_stack unless errors_stack.empty?
+    end
+  end
+end

data/lib/evil_events/core/events/notifier/worker/executor.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# @api private
+# since 0.3.0
+class EvilEvents::Core::Events::Notifier::Worker::Executor
+  # @since 0.3.0
+  include EvilEvents::Core::Events::Notifier::Logging
+
+  # @api public
+  # @since 0.3.0
+  FALLBACK_POLICIES = {
+    exception:   :abort,
+    ignorance:   :discard,
+    main_thread: :caller_runs
+  }.freeze
+
+  # @return [Concurrent::ThreadPoolExecutor]
+  #
+  # @api private
+  # @since 0.3.0
+  attr_reader :raw_executor
+
+  # @return [Hash]
+  #
+  # @api private
+  # @since 0.3.0
+  attr_reader :options
+
+  # @option min_threads [Integer]
+  # @option max_threads [Integer]
+  # @option max_queue [Integer]
+  # @option fallback_policy [Symbol]
+  # @raise [EvilEvents::IncorrectFallbackPolicyError]
+  #
+  # @api private
+  # @since 0.3.0
+  def initialize(min_threads:, max_threads:, max_queue:, fallback_policy:)
+    raise EvilEvents::IncorrectFallbackPolicyError unless FALLBACK_POLICIES[fallback_policy]
+
+    @options = {
+      min_threads:     min_threads,
+      max_threads:     max_threads,
+      max_queue:       max_queue,
+      fallback_policy: FALLBACK_POLICIES[fallback_policy]
+    }.freeze
+
+    initialize_raw_executor!(**@options)
+  end
+
+  # @param job [EvilEvents::Core::Events::Notifier::Job]
+  # @raise [EvilEvents::WorkerDisabledOrBusyError]
+  # @return [Concurrent::Promise]
+  #
+  # @api private
+  # @sicne 0.3.0
+  # rubocop:disable Metrics/AbcSize, Style/MultilineBlockChain
+  def execute(job)
+    Concurrent::Promise.new(executor: raw_executor) do
+      job.perform
+    end.on_success do
+      log_success(job.event, job.subscriber)
+    end.on_error do |error|
+      job.event.__call_on_error_hooks__(error)
+      log_failure(job.event, job.subscriber)
+    end.execute
+  rescue Concurrent::RejectedExecutionError
+    raise EvilEvents::WorkerDisabledOrBusyError
+  end
+  # rubocop:enable Metrics/AbcSize, Style/MultilineBlockChain
+
+  # @return void
+  #
+  # @api private
+  # @since 0.3.0
+  def shutdown!
+    raw_executor.shutdown
+    raw_executor.wait_for_termination
+  end
+
+  # @return void
+  #
+  # @api private
+  # @since 0.3.0
+  def restart!
+    shutdown!
+    initialize_raw_executor!(**options)
+  end
+
+  private
+
+  # @option min_threads [Integer]
+  # @option max_threads [Integer]
+  # @option max_queue [Integer]
+  # @option fallback_policy [Symbol]
+  # @return [Concurrent::ThreadPoolExecutor]
+  #
+  # @api private
+  # @since 0.3.0
+  def initialize_raw_executor!(**options)
+    @raw_executor = Concurrent::ThreadPoolExecutor.new(**options)
+  end
+end

data/lib/evil_events/core/events/notifier/worker/job.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# @api private
+# since 0.3.0
+class EvilEvents::Core::Events::Notifier::Worker::Job
+  # @return [EvilEvents::Core::Events::Subscriber]
+  #
+  # @api private
+  # @since 0.3.0
+  attr_reader :subscriber
+
+  # @return [EvilEvents::Core::Events::AbstractEvent]
+  #
+  # @api private
+  # @since 0.3.0
+  attr_reader :event
+
+  # @param event [EvilEvents::Core::Events::AbstractEvent]
+  # @param subscriber [EvilEvents::Core::Events::Subscriber]
+  #
+  # @api private
+  # @since 0.3.0
+  def initialize(event, subscriber)
+    @event = event
+    @subscriber = subscriber
+  end
+
+  # @return void
+  #
+  # @api private
+  # @since 0.3.0
+  def perform
+    subscriber.notify(event)
+  end
+end

data/lib/evil_events/core/events/notifier/worker.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module EvilEvents::Core::Events::Notifier
+  # @api private
+  # @since 0.3.0
+  class Worker < Abstract
+    # @since 0.3.0
+    extend Forwardable
+
+    # @api public
+    # @since 0.3.0
+    MAIN_THREAD_POLICY = :main_thread
+
+    # @api public
+    # @since 0.3.0
+    IGNORANCE_POLICY = :ignorance
+
+    # @api public
+    # @since 0.3.0
+    EXCEPTION_POLICY = :exception
+
+    # @since 0.3.0
+    def_delegators :executor, :shutdown!, :restart!
+
+    # @return [EvilEvents::Core::Events::Notifier::Worker::Executor]
+    #
+    # @api private
+    # @since 0.3.0
+    attr_reader :executor
+
+    # @option min_threads [Integer]
+    # @option max_threads [Integer]
+    # @option max_queue [Integer]
+    # @option fallback_policy [Symbol]
+    #
+    # @see EvilEvents::Core::Events::Notifier::Worker::Executor
+    #
+    # @api private
+    # @since 0.3.0
+    def initialize(min_threads:, max_threads:, max_queue:, fallback_policy: MAIN_THREAD_POLICY)
+      @executor = Executor.new(
+        min_threads:     min_threads,
+        max_threads:     max_threads,
+        max_queue:       max_queue,
+        fallback_policy: fallback_policy
+      )
+    end
+
+    # @param manager [EvilEvents::Core::Events::Manager]
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    #
+    # @api private
+    # @since 0.3.0
+    def notify(manager, event)
+      event.__call_before_hooks__
+      manager.subscribers.each { |subscriber| schedule_job(event, subscriber) }
+      event.__call_after_hooks__
+    end
+
+    private
+
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @param subscriber [EvilEvents::Core::Events::Subscriber]
+    #
+    # @api private
+    # @since 0.3.0
+    def schedule_job(event, subscriber)
+      executor.execute(Job.new(event, subscriber))
+    end
+  end
+end

data/lib/evil_events/core/events/notifier.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.3.0
+module EvilEvents::Core::Events::Notifier
+end

data/lib/evil_events/core/events/serializers/hash.rb

@@ -9,12 +9,14 @@ class EvilEvents::Core::Events::Serializers
 
     class << self
       # @param event [EvilEvents::Core::Events::AbstractEvent]
-      # @raise [SerializationError]
+      # @raise [EvilEvents::SerializationError]
       # @return [::Hash]
       #
       # @since 0.1.0
       def serialize(event)
-        raise SerializationError unless event.is_a?(EvilEvents::Core::Events::AbstractEvent)
+        unless event.is_a?(EvilEvents::Core::Events::AbstractEvent)
+          raise EvilEvents::SerializationError
+        end
 
         {
           id:       event.id,
@@ -29,21 +31,21 @@ class EvilEvents::Core::Events::Serializers
       # rubocop:disable Metrics/PerceivedComplexity
 
       # @param hash [::Hash]
-      # @raise [DeserializationError]
+      # @raise [EvilEvents::DeserializationError]
       # @return [EvilEvents::Core::Events::AbstractEvent]
       #
       # @since 0.1.0
       def deserialize(hash)
-        raise DeserializationError unless hash.is_a?(::Hash)
+        raise EvilEvents::DeserializationError unless hash.is_a?(::Hash)
 
         event_id       = hash[:id]       || hash['id']
         event_type     = hash[:type]     || hash['type']
         event_payload  = hash[:payload]  || hash['payload']
         event_metadata = hash[:metadata] || hash['metadata']
 
-        raise DeserializationError unless event_type && event_payload && event_metadata
-        raise DeserializationError unless event_payload.is_a?(::Hash)
-        raise DeserializationError unless event_metadata.is_a?(::Hash)
+        raise EvilEvents::DeserializationError unless event_type && event_payload && event_metadata
+        raise EvilEvents::DeserializationError unless event_payload.is_a?(::Hash)
+        raise EvilEvents::DeserializationError unless event_metadata.is_a?(::Hash)
 
         restore_event_instance(
           type:     event_type,

data/lib/evil_events/core/events/serializers/json.rb

@@ -9,12 +9,14 @@ class EvilEvents::Core::Events::Serializers
 
     class << self
       # @param event [EvilEvents::Core::Events::AbstractEvent]
-      # @raise [SerializationError]
+      # @raise [EvilEvents::SerializationError]
       # @return [::Hash]
       #
       # @since 0.1.0
       def serialize(event)
-        raise SerializationError unless event.is_a?(EvilEvents::Core::Events::AbstractEvent)
+        unless event.is_a?(EvilEvents::Core::Events::AbstractEvent)
+          raise EvilEvents::SerializationError
+        end
 
         ::JSON.generate(
           id:       event.id,
@@ -25,12 +27,12 @@ class EvilEvents::Core::Events::Serializers
       end
 
       # @param json [String]
-      # @raise [DeserializationError]
+      # @raise [EvilEvents::DeserializationError]
       # @return [EvilEvents::Core::Events::AbstractEvent]
       #
       # @since 0.1.0
       def deserialize(json)
-        raise DeserializationError unless json.is_a?(String)
+        raise EvilEvents::DeserializationError unless json.is_a?(String)
 
         begin
           json_hash      = ::JSON.parse(json, symbolize_names: true)
@@ -38,9 +40,12 @@ class EvilEvents::Core::Events::Serializers
           event_type     = json_hash[:type]
           event_payload  = json_hash[:payload]
           event_metadata = json_hash[:metadata]
-          raise DeserializationError unless event_type && event_payload && event_metadata
+
+          unless event_type && event_payload && event_metadata
+            raise EvilEvents::DeserializationError
+          end
         rescue ::JSON::ParserError
-          raise DeserializationError
+          raise EvilEvents::DeserializationError
         end
 
         restore_event_instance(

data/lib/evil_events/core/events/serializers.rb

@@ -6,12 +6,5 @@ module EvilEvents::Core::Events
   class Serializers
     # @since 0.1.0
     extend EvilEvents::Shared::DependencyContainer::Mixin
-
-    # @since 0.1.0
-    SerializersError = Class.new(EvilEvents::Core::Error)
-    # @since 0.1.0
-    SerializationError = Class.new(SerializersError)
-    # @since 0.1.0
-    DeserializationError = Class.new(SerializersError)
   end
 end

data/lib/evil_events/core/events/subscriber/mixin.rb

@@ -6,11 +6,11 @@ class EvilEvents::Core::Events::Subscriber
   Mixin = EvilEvents::Shared::ClonableModuleBuilder.build do
     # @param event_type [Array<String, Class{EvilEvents::Core::Events::AbstractEvent}, Regexp>]
     # @param delegator [String, Symbol, NilClass]
-    # @raise [EvilEvents::Core::ArgumentError]
+    # @raise [EvilEvents::ArgumentError]
     #
     # @since 0.2.0
     def subscribe_to(*event_types, delegator: nil)
-      raise EvilEvents::Core::ArgumentError unless event_types.all? do |event_type|
+      raise EvilEvents::ArgumentError unless event_types.all? do |event_type|
         event_type.is_a?(Class) ||
         event_type.is_a?(String) ||
         event_type.is_a?(Regexp) ||

data/lib/evil_events/core/events.rb

@@ -21,9 +21,22 @@ module EvilEvents::Core
     require_relative 'events/event_extensions/class_signature'
     require_relative 'events/event_extensions/class_signature/signature'
     require_relative 'events/event_extensions/class_signature/equalizer'
+    require_relative 'events/event_extensions/hookable'
+    require_relative 'events/event_extensions/hookable/abstract_hook'
+    require_relative 'events/event_extensions/hookable/after_emit_hook'
+    require_relative 'events/event_extensions/hookable/before_emit_hook'
+    require_relative 'events/event_extensions/hookable/on_error_hook'
+    require_relative 'events/notifier'
+    require_relative 'events/notifier/logging'
+    require_relative 'events/notifier/abstract'
+    require_relative 'events/notifier/sequential'
+    require_relative 'events/notifier/worker'
+    require_relative 'events/notifier/worker/executor'
+    require_relative 'events/notifier/worker/job'
+    require_relative 'events/notifier/builder'
+    require_relative 'events/notifier/proxy'
     require_relative 'events/abstract_event'
     require_relative 'events/manager'
-    require_relative 'events/manager/notifier'
     require_relative 'events/manager/subscriber_list'
     require_relative 'events/manager_factory'
     require_relative 'events/manager_registry'

data/lib/evil_events/core/system/broadcaster.rb

@@ -14,10 +14,16 @@ class EvilEvents::Core::System
     # @since 0.1.0
     attr_reader :adapters_container
 
+    # @return [EvilEvents::Core::Events::Notifier::Abstract]
+    #
+    # @since 0.3.0
+    attr_reader :event_notifier
+
     # @since 0.1.0
     def initialize
-      @event_emitter      = EvilEvents::Core::Broadcasting::Emitter.new
       @adapters_container = EvilEvents::Core::Broadcasting::Adapters.new
+      @event_emitter      = EvilEvents::Core::Broadcasting::Emitter.new
+      @event_notifier     = EvilEvents::Core::Events::Notifier::Proxy.new
 
       @adapters_container.register_core_adapters!
     end
@@ -55,5 +61,21 @@ class EvilEvents::Core::System
     def register_adapter(adapter_name, adapter_object)
       adapters_container.register(adapter_name, adapter_object)
     end
+
+    # @param manager [EvilEvents::Core::Events::Manager]
+    # @param event [EvilEvents::Core::Events::AbstractEvent]
+    # @return void
+    #
+    # @since 0.3.0
+    def process_event_notification(manager, event)
+      event_notifier.notify(manager, event)
+    end
+
+    # @return void
+    #
+    # @since 0.3.0
+    def restart_event_notifier
+      event_notifier.restart!
+    end
   end
 end

data/lib/evil_events/core/system/mock.rb

@@ -106,5 +106,12 @@ class EvilEvents::Core::System
     # @see EvilEvents::Core::System
     # @since 0.2.0
     def registered_events; end
+
+    # @see EvilEvents::Core::System
+    # @since 0.3.0
+    def process_event_notification(manager, event); end
+
+    # @see EvilEvents::Core::System
+    def restart_event_notifier; end
   end
 end

data/lib/evil_events/core/system.rb

@@ -22,7 +22,9 @@ module EvilEvents::Core
                    :emit,
                    :raw_emit,
                    :resolve_adapter,
-                   :register_adapter
+                   :register_adapter,
+                   :process_event_notification,
+                   :restart_event_notifier
 
     # @see EvilEvents::Core::System::EventManager
     # @since 0.1.0

data/lib/evil_events/core.rb

@@ -4,7 +4,6 @@ module EvilEvents
   # @api private
   # @since 0.1.0
   module Core
-    require_relative 'core/error'
     require_relative 'core/activity_logger'
     require_relative 'core/broadcasting'
     require_relative 'core/events'