announcer 0.5.1

data/lib/ribbon/event_bus/mixins.rb

@@ -0,0 +1,7 @@
+module Ribbon::EventBus
+  module Mixins
+    autoload(:HasInstance, 'ribbon/event_bus/mixins/has_instance')
+    autoload(:HasConfig, 'ribbon/event_bus/mixins/has_config')
+    autoload(:Serializable, 'ribbon/event_bus/mixins/serializable')
+  end
+end

data/lib/ribbon/event_bus/mixins/has_config.rb

@@ -0,0 +1,45 @@
+module Ribbon::EventBus
+  module Mixins
+    module HasConfig
+      def self.included(base)
+        raise "HasConfig requires HasInstance" unless base < HasInstance
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def config_key(key)
+          config_keys << key.to_sym
+        end
+
+        def config_keys(*keys)
+          unless keys.empty?
+            _has_config_values[:keys] = keys.map(&:to_sym)
+          else
+            _has_config_values[:keys] ||= _has_config_ancestor_keys
+          end
+        end
+
+        def _has_config_ancestor_keys
+          ancestors[1] < HasConfig ? ancestors[1].config_keys.dup : []
+        end
+
+        def _has_config_values
+          @__has_config_values ||= {}
+        end
+      end
+
+      def config
+        _has_config_config
+      end
+
+      def _has_config_config
+        @__has_config_config ||= _has_config_load_config.dup
+      end
+
+      def _has_config_load_config
+        keys = self.class.config_keys
+        keys.inject(instance.config) { |c, k| c.send(k) }
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/mixins/has_instance.rb

@@ -0,0 +1,13 @@
+module Ribbon
+  module EventBus::Mixins
+    module HasInstance
+      def instance
+        (defined?(@instance) && @instance) || EventBus.instance
+      end
+
+      def plugins
+        instance.send(:plugins)
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/mixins/serializable.rb

@@ -0,0 +1,183 @@
+require 'base64'
+
+module Ribbon::EventBus
+  module Mixins
+    module Serializable
+      MAGIC = :SRLZ
+      VERSION = 1
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def serialize_with(*args)
+          _serializable_values[:args] = args.map(&:to_sym)
+        end
+
+        def deserialize(encoded)
+          marshalled = _serializable_decode(encoded)
+          package = _serializable_unmarshal(marshalled)
+          _serializable_load_package(package)
+        end
+
+        def _serializable_load_package(package)
+          klass, args = _serializable_unpackage(package)
+          klass._deserialize_args(args)
+        end
+
+        def _deserialize_args(args)
+          args = args.map { |arg| _deserialize_arg(arg) }
+
+          if respond_to?(:load_from_serialized)
+            load_from_serialized(*args)
+          else
+            new(*args)
+          end
+        end
+
+        def _deserialize_arg(arg)
+          if _serializable_valid_package?(arg, false)
+            _serializable_load_package(arg)
+          else
+            arg
+          end
+        end
+
+        ###
+        # Encoding
+        ###
+        def _serializable_encode(marshalled)
+          Base64.strict_encode64(marshalled) # => encoded
+        end
+
+        def _serializable_decode(encoded)
+          begin
+            Base64.strict_decode64(encoded) # => marshalled
+          rescue ArgumentError
+            raise Errors::SerializableError, 'serialized string not encoded properly'
+          end
+        end
+
+        ###
+        # Marshalling
+        ###
+        def _serializable_marshal(package)
+          Marshal.dump(package) # => marshalled
+        end
+
+        def _serializable_unmarshal(marshalled)
+          begin
+            Marshal.load(marshalled) # => package
+          rescue TypeError
+            raise Errors::SerializableError, 'incorrect format'
+          end
+        end
+
+        ###
+        # Class Encoding
+        ###
+
+        def _serializable_encode_class(klass)
+          klass.name.to_s.sub('Ribbon::EventBus::', '').to_sym
+        end
+
+        def _serializable_decode_class(encoded_klass)
+          Ribbon::EventBus.const_get(encoded_klass.to_s)
+        end
+
+        ###
+        # Packaging
+        ###
+        def _serializable_package(klass, args)
+          encoded_klass = _serializable_encode_class(klass)
+          [MAGIC, VERSION, encoded_klass] + args # => package
+        end
+
+        def _serializable_valid_package?(package, noisy=true)
+          unless package.is_a?(Array)
+            if noisy
+              raise Errors::SerializableError, 'not a package'
+            else
+              return false
+            end
+          end
+
+          magic, version, class_name = package
+
+          # Check Magic
+          unless magic == MAGIC
+            if noisy
+              raise Errors::SerializableError, 'invalid serialized package'
+            else
+              return false
+            end
+          end
+
+          # Check Version
+          unless version == VERSION
+            if noisy
+              raise Errors::SerializableError, 'unsupported package version'
+            else
+              return false
+            end
+          end
+
+          # Check Class Name
+          unless class_name.is_a?(Symbol)
+            if noisy
+              raise Errors::SerializableError, 'invalid class name'
+            else
+              return false
+            end
+          end
+
+          return true
+        end
+
+        def _serializable_unpackage(package)
+          _serializable_valid_package?(package)
+          magic, version, encoded_klass, *args = package
+          klass = _serializable_decode_class(encoded_klass)
+          [klass, args]
+        end
+
+        ###
+        # Helpers
+        ###
+        def _serializable_values
+          @__serializable_values ||= {}
+        end
+
+        def _serializable_args
+          _serializable_values[:args] or
+            raise Errors::SerializableError, "Missing serialize_with definition"
+        end
+      end
+
+      def serialize
+        package = _serializable_package
+        marshalled = self.class._serializable_marshal(package)
+        self.class._serializable_encode(marshalled)
+      end
+
+      def _serializable_package
+        args = _serializable_args.map { |arg| _serialize_arg(send(arg)) }
+        self.class._serializable_package(self.class, args)
+      end
+
+      def _serialize_arg(arg)
+        case arg
+        when Serializable
+          arg._serializable_package
+        else
+          arg
+        end
+      end
+
+      def _serializable_args
+        self.class._serializable_args
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/plugins.rb

@@ -0,0 +1,6 @@
+module Ribbon::EventBus
+  module Plugins
+    autoload(:Plugin,        'ribbon/event_bus/plugins/plugin')
+    autoload(:LoggingPlugin, 'ribbon/event_bus/plugins/logging_plugin')
+  end
+end

data/lib/ribbon/event_bus/plugins/logging_plugin.rb

@@ -0,0 +1,68 @@
+require 'logger'
+
+module Ribbon::EventBus
+  module Plugins
+    class LoggingPlugin < Plugin
+      config_key :logging
+
+      def logger
+        @_logger ||= _load_logger
+      end
+
+      around_publish do |event|
+        _run('Publishing', event) { publish }
+      end
+
+      around_resque_publish do |event|
+        _run('Publishing on Resque', event) { resque_publish }
+      end
+
+      around_subscription do |sub, event|
+        _run('Executing Subscription', sub) { subscription }
+      end
+
+      private
+      def _load_logger
+        if config.logger?
+          config.logger
+        else
+          Logger.new(STDOUT).tap { |logger|
+            logger.level = _load_level
+          }
+        end
+      end
+
+      def _load_level
+        case config.level
+        when :info, nil
+          Logger::INFO
+        when :warn
+          Logger::WARN
+        when :error
+          Logger::ERROR
+        when :fatal
+          Logger::FATAL
+        else
+          raise Errors::PluginError, "Invalid plugins.logging.level: #{config.level.inspect}"
+        end
+      end
+
+      def _run(subject, object, &block)
+        logger.debug("#{subject}: #{object}")
+
+        if config.log_exceptions?
+          begin
+            block.call
+          rescue Exception => e
+            logger.fatal("Exception raised when #{subject.downcase} #{object}: #{e.inspect}")
+            raise
+          end
+        else
+          block.call
+        end
+
+        logger.debug("Finished #{subject}: #{object}")
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/plugins/plugin.rb

@@ -0,0 +1,22 @@
+require 'ribbon/plugins'
+
+module Ribbon::EventBus
+  module Plugins
+    class Plugin < Ribbon::Plugins::Plugin
+      include Mixins::HasInstance
+      include Mixins::HasConfig
+
+      config_key :plugins
+
+      def initialize(plugins, params={})
+        super(plugins)
+        @instance = plugins.component
+        @_params = params || {}
+      end
+
+      def config
+        @__config ||= super.merge_hash!(@_params)
+      end
+    end
+  end
+end

data/lib/ribbon/event_bus/publishers.rb

@@ -0,0 +1,54 @@
+module Ribbon::EventBus
+  module Publishers
+    autoload(:Publisher,
+      'ribbon/event_bus/publishers/publisher')
+    autoload(:ProcPublisher,
+      'ribbon/event_bus/publishers/proc_publisher')
+    autoload(:SubscriptionsPublisher,
+      'ribbon/event_bus/publishers/subscriptions_publisher')
+    autoload(:ResquePublisher,
+      'ribbon/event_bus/publishers/resque_publisher')
+    autoload(:RemoteResquePublisher,
+      'ribbon/event_bus/publishers/remote_resque_publisher')
+    autoload(:AsyncResquePublisher,
+      'ribbon/event_bus/publishers/async_resque_publisher')
+
+    module_function
+    def load_for_instance(instance)
+      config = instance.config
+      config.publish_to? ? _load_for_instance(instance, config.publish_to) : []
+    end
+
+    def _load_for_instance(instance, publishers)
+      publishers.map { |publisher| _load_with_args(publisher, instance) }
+    end
+
+    def _load_with_args(publisher, *args)
+      case publisher
+      when Array
+        _load_with_args(publisher[0], *(args + publisher[1..-1]))
+      else
+        load(publisher).new(*args)
+      end
+    end
+
+    def load(publisher)
+      case publisher
+      when String, Symbol then _load_from_string(publisher.to_s)
+      when Proc           then _load_from_proc(publisher)
+      when Publisher      then publisher
+      else raise Errors::InvalidPublisherError, publisher.inspect
+      end
+    end
+
+    def _load_from_string(publisher_name)
+      const_get((publisher_name.split('_').map(&:capitalize) + ['Publisher']).join)
+    rescue NameError
+      raise Errors::InvalidPublisherNameError, publisher_name
+    end
+
+    def _load_from_proc(publisher_proc)
+      ProcPublisher.new(&publisher_proc)
+    end
+  end
+end

data/lib/ribbon/event_bus/publishers/async_resque_publisher.rb

@@ -0,0 +1,81 @@
+require 'resque'
+require 'redis'
+require 'celluloid/current'
+
+module Ribbon::EventBus
+  module Publishers
+    class AsyncResquePublisher < Publisher
+      config_key :resque
+
+      attr_reader :resque
+
+      def initialize(instance=nil, params={})
+        super
+        @resque = config.resque? ? config.resque : Resque
+      end
+
+      def worker_id
+        @__worker_id ||= "event_bus_resque_worker_#{object_id}".to_sym
+      end
+
+      ##
+      # The suprvisor created in the initializer will restart the PublisherWorker
+      # but there can be a short period of time when the actor returned by
+      # Celluloid::Actor[...] is dead. To avoid that we sleep for a millisecond
+      # to give it time to create a new worker thread.  We try three times before
+      # giving up.
+      #
+      # This should ensure that it's unlikely for a dead worker to be returned.
+      # However, if a dead worker is returned, then async calls will silently
+      # fail, allowing normal execution. This makes firing events best-effort.
+      def worker
+        # Retrieve the PublisherWorker or start the supervisor.
+        w = Celluloid::Actor[worker_id] || PublisherWorker.supervise(
+          args: [self],
+          as: worker_id
+        ).send(worker_id)
+
+        3.times {
+          if w.dead?
+            sleep(0.001)
+            w = Celluloid::Actor[worker_id]
+          else
+            break
+          end
+        }
+
+        w
+      end
+
+      ##
+      # Needs to exist for the ResquePublisher::PublisherJob to succeed.
+      def subscription_queue_formatter
+        ResquePublisher.subscription_queue_formatter(config)
+      end
+
+      def publish(event)
+        super
+        worker.async.publish(event) unless event.subscriptions.empty?
+      end
+
+      class PublisherWorker
+        include Celluloid
+
+        attr_reader :publisher
+
+        def initialize(publisher)
+          @publisher = publisher
+        end
+
+        def publish(event)
+          publisher.resque.enqueue_to(
+            publisher.config.publisher_queue.to_sym,
+            ResquePublisher::PublisherJob,
+            event.serialize,
+            :async_resque
+          )
+        end
+      end # PublisherWorker
+    end
+  end
+end