announcer 0.5.1

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

@@ -0,0 +1,22 @@
+module Ribbon::EventBus
+  module Publishers
+    class ProcPublisher < Publisher
+      def initialize(instance=nil, &block)
+        super
+
+        raise Errors::MissingProcError unless block_given?
+        raise Errors::InvalidArityError, 'Proc arity must be 1' unless block.arity == 1
+        @_block = block
+      end
+
+      def new(instance=nil)
+        self.class.new(instance, &@_block)
+      end
+
+      def publish(event)
+        super
+        @_block.call(event)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Ribbon::EventBus
+  module Publishers
+    class Publisher
+      include Mixins::HasInstance
+      include Mixins::HasConfig
+      config_key :publishers
+
+      def initialize(instance=nil, params={})
+        @instance = instance
+        @_params = params
+      end
+
+      def config
+        @__config ||= super.merge_hash!(@_params)
+      end
+
+      ###
+      # #publish(event)
+      #
+      # This method should be overridden by a subclass. Make sure to call "super"
+      # so that proper sanity checks can be performed.
+      ###
+      def publish(event)
+        unless event.instance == instance
+          raise Errors::PublisherError, "Event for different instance"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'uri'
+require 'redis'
+require 'redis/namespace'
+
+module Ribbon::EventBus
+  module Publishers
+    class RemoteResquePublisher < Publisher
+      config_key :remote_resque
+
+      def publish(event)
+        super
+
+        # Based on Resque 1.25.2
+
+        # Resque call stack:
+        # -> Resque.enqueue(klass, *args)
+        # -> Resque.enqueue_to(queue, klass, *args)
+        # -> Job.create(queue, klass, *args)
+        # -> Resque.push(queue, class: klass.to_s, args: args)
+
+        # These should be the same as the args passed to Resque.enqueue in
+        # ResquePublisher#publish(event).
+        args = [
+          event.serialize
+        ]
+
+        enqueue_to(config.queue.to_s, Publishers::ResquePublisher::PublisherJob, *args)
+      end
+
+      def redis
+        @redis ||= _redis
+      end
+
+      private
+
+      ##########################################################################
+      # Methods copied from Resque v1.25.2
+      ##########################################################################
+
+      def enqueue_to(queue, klass, *args)
+        # This is a functionality copy, not a direct code copy.
+        # Here, I'm skipping the call to Job.create(queue, klass, *args) and
+        # calling push directly.
+        push(queue, class: klass.to_s, args: args)
+      end
+
+      # Resque::push(queue, items)
+      def push(queue, item)
+        redis.pipelined do
+          watch_queue(queue)
+          redis.rpush "queue:#{queue}", encode(item)
+        end
+      end
+
+      # Resque::watch_queue
+      def watch_queue(queue)
+        redis.sadd(:queues, queue.to_s)
+      end
+
+      def encode(object)
+        # This one we can call directly.
+        Resque.encode(object)
+      end
+
+      ##########################################################################
+      # Helper Methods
+      ##########################################################################
+
+      def _redis
+        if config.redis?
+          config.redis
+        elsif config.redis_url?
+          redis = Redis.connect(url: config.redis_url, thread_safe: true)
+          Redis::Namespace.new(config.redis_namespace.to_sym, redis: redis)
+        else
+          raise Errors::RemoteResquePublisherError, "missing redis configuration"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'resque'
+
+module Ribbon::EventBus
+  module Publishers
+    class ResquePublisher < Publisher
+      config_key :resque
+
+      def initialize(instance=nil, params={})
+        super
+        _disallow_multiple_per_instance
+      end
+
+      def publish(event)
+        super
+
+        unless event.subscriptions.empty?
+          PublisherJob.set_queue(config.publisher_queue.to_sym)
+          Resque.enqueue(PublisherJob, event.serialize)
+        end
+      end
+
+      def subscription_queue_formatter
+        self.class.subscription_queue_formatter(config)
+      end
+
+      class << self
+        def subscription_queue_formatter(config)
+          if config.subscription_queue_formatter?
+            formatter = config.subscription_queue_formatter
+            case formatter
+            when Array
+              formatter.last
+            when Proc
+              formatter
+            else
+              raise Errors::PublisherError, "Invalid subscription_queue_formatter: #{formatter.inspect}"
+            end
+          else
+            lambda { |subscription| "subscriptions_p#{subscription.priority}" }
+          end
+        end
+      end # Class Methods
+
+      module PublisherJob
+        def self.set_queue(queue)
+          @queue = queue
+        end
+
+        def self.perform(serialized_event, publisher_name=:resque)
+          event = Event.deserialize(serialized_event)
+          instance = event.instance
+
+          publisher = instance.find_publisher(publisher_name)
+          raise Errors::PublisherError, 'No ResquePublisher found' unless publisher
+          queue_formatter = publisher.subscription_queue_formatter
+
+          instance.plugins.perform(:resque_publish, event) do |event|
+            event.subscriptions.each { |s|
+              SubscriptionJob.set_queue(queue_formatter.call(s).to_sym)
+              Resque.enqueue(SubscriptionJob, s.serialize, event.serialize)
+            }
+          end
+        end
+      end # PublisherJob
+
+      module SubscriptionJob
+        def self.set_queue(queue)
+          @queue = queue
+        end
+
+        def self.perform(serialized_sub, serialized_event)
+          subscription = Subscription.deserialize(serialized_sub)
+          event = Event.deserialize(serialized_event)
+          subscription.handle(event)
+        end
+      end # SubscriptionJob
+
+      private
+      def _disallow_multiple_per_instance
+        if instance.has_publisher?(:resque)
+          raise Errors::PublisherError,
+            "cannot have multiple ResquePublishers in an EventBus instance"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Ribbon::EventBus::Publishers
+  class SubscriptionsPublisher < Publisher
+    def publish(event)
+      super
+      event.subscriptions.each { |subscription| subscription.handle(event) }
+    end
+  end
+end

data/lib/ribbon/event_bus/subscription.rb

@@ -0,0 +1,165 @@
+require 'digest'
+
+module Ribbon::EventBus
+  class Subscription
+    include Mixins::HasInstance
+    include Mixins::HasConfig
+    include Mixins::Serializable
+
+    config_key :subscriptions
+    serialize_with :instance, :identifier
+
+    attr_reader :name
+    attr_reader :event_name
+    attr_reader :priority
+    attr_reader :identifier
+
+    def initialize(event_name, params={}, &block)
+      @event_name = event_name.to_sym
+      @_block = block
+
+      _evaluate_params(params)
+
+      @identifier = _generate_identifier
+
+      if instance.find_subscription(identifier)
+        raise Errors::DuplicateIdentifierError, "give this subscription a unique name"
+      else
+        instance._register_subscription(self)
+      end
+    end
+
+    def self.load_from_serialized(instance, identifier)
+      instance.find_subscription(identifier)
+    end
+
+    def handle(event)
+      raise Errors::UnexpectedEventError, 'wrong name' unless event.name == event_name
+      raise Errors::UnexpectedEventError, 'wrong instance' unless event.instance == instance
+
+      plugins.perform(:subscription, self, event) { |subscription, event|
+        @_block.call(event)
+      }
+    end
+
+    def to_s
+      "Subscription(on #{event_name}: #{name || _path})"
+    end
+
+    private
+
+    def _path
+      @__path ||= _determine_path
+    end
+
+    ##
+    # Determines the file path of the ruby code defining the subscription.
+    # It's important that this is called from within the initializer to get the
+    # desired effect.
+    def _determine_path
+      path = File.expand_path('../..', __FILE__)
+
+      # Will be something like:
+      # "/path/to/file.rb:47:in `method_name'"
+      non_event_bus_caller = caller.find { |c| !c.start_with?(path) }
+
+      unless non_event_bus_caller
+        # This is not expected to occur.
+        raise Errors::SubscriptionError, "Could not find non-EventBus caller"
+      end
+
+      non_event_bus_caller
+    end
+
+    ##
+    # Generates a unique identifier for this subscription which will be used to
+    # "serialize" it.
+    #
+    # The goal here is to generate a identifier that is the same across different
+    # processes and servers and that ideally changes infrequently between
+    # application versions, but when it does change, it should do so predictably.
+    def _generate_identifier
+      # Cut off everything from the line number onward. That way, the identifier
+      # does not change when the subscription block moves to a different line.
+      index = _path.rindex(/:\d+:/) - 1
+      path = _path[0..index]
+
+      raise Errors::SubscriptionError, "Invalid path: #{path}" unless File.exists?(path)
+
+      Digest::MD5.hexdigest("#{path}:#{event_name}:#{name}").to_sym
+    end
+
+    def _symbol_to_priority(sym)
+      (@__symbol_to_priority_map ||= _generate_priority_shortcut_map)[sym]
+    end
+
+    def _generate_priority_shortcut_map(max_priority=config.max_priority)
+      {}.tap { |map|
+        map.merge!(highest: 1, lowest: max_priority)
+        map[:medium] = (map[:lowest] / 2.0).ceil
+        map[:high] = (map[:medium] / 2.0).ceil
+        map[:low] = ((map[:lowest] + map[:medium]) / 2.0).ceil
+      }.freeze
+    end
+
+    ############################################################################
+    # Parameter Evaluation Logic
+    #
+    # This evaluates the parameters passed to the initializer.
+    ############################################################################
+
+    ###
+    # Root evaluation method.
+    ###
+    def _evaluate_params(params)
+      @instance = params[:instance]
+      @name = params[:name].to_s
+      @priority = _evaluate_priority(params[:priority])
+    end
+
+    ###
+    # Priority evaluation
+    ###
+    def _evaluate_priority(priority)
+      case priority
+      when Integer
+        _evaluate_priority_int(priority)
+      when String, Symbol
+        _evaluate_priority_symbol(priority.to_sym)
+      when NilClass
+        _evaluate_priority_nil
+      else
+        raise Errors::InvalidPriorityError, priority.inspect
+      end
+    end
+
+    # Evaluate an integer as a priority.
+    def _evaluate_priority_int(int)
+      raise Errors::InvalidPriorityError, int unless int > 0 && int <= config.max_priority
+      int
+    end
+
+    # Evaluate a symbol as a priority.
+    def _evaluate_priority_symbol(sym)
+      if (priority = _symbol_to_priority(sym))
+        _evaluate_priority(priority)
+      else
+        raise Errors::InvalidPriorityError, sym.inspect
+      end
+    end
+
+    # Evaluate nil as a priority.
+    def _evaluate_priority_nil
+      # Need to specify value explicitly here, otherwise in the call to
+      # _evaluate_priority, the case statement won't recognize it as a Symbol.
+      # That's because when calls Symbol::=== to evaluate a match.
+      priority = config.default_priority
+
+      if priority
+        _evaluate_priority(priority)
+      else
+        raise Errors::InvalidPriorityError, priority.inspect
+      end
+    end
+  end # Event
+end # Ribbon::EventBus

data/lib/ribbon/event_bus/version.rb

@@ -0,0 +1,5 @@
+module Ribbon
+  module EventBus
+    VERSION = "0.5.1"
+  end
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: announcer
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- Robert Honer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ribbon-plugins
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.2
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.13
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.13
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.2
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An asynchronous event bus for Ruby.
+email:
+- robert@ribbonpayments.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- config/defaults.yml
+- lib/ribbon/event_bus.rb
+- lib/ribbon/event_bus/config.rb
+- lib/ribbon/event_bus/errors.rb
+- lib/ribbon/event_bus/event.rb
+- lib/ribbon/event_bus/instance.rb
+- lib/ribbon/event_bus/mixins.rb
+- lib/ribbon/event_bus/mixins/has_config.rb
+- lib/ribbon/event_bus/mixins/has_instance.rb
+- lib/ribbon/event_bus/mixins/serializable.rb
+- lib/ribbon/event_bus/plugins.rb
+- lib/ribbon/event_bus/plugins/logging_plugin.rb
+- lib/ribbon/event_bus/plugins/plugin.rb
+- lib/ribbon/event_bus/publishers.rb
+- lib/ribbon/event_bus/publishers/async_resque_publisher.rb
+- lib/ribbon/event_bus/publishers/proc_publisher.rb
+- lib/ribbon/event_bus/publishers/publisher.rb
+- lib/ribbon/event_bus/publishers/remote_resque_publisher.rb
+- lib/ribbon/event_bus/publishers/resque_publisher.rb
+- lib/ribbon/event_bus/publishers/subscriptions_publisher.rb
+- lib/ribbon/event_bus/subscription.rb
+- lib/ribbon/event_bus/version.rb
+homepage: http://github.com/ribbon/event_bus
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: An asynchronous event bus for Ruby.
+test_files: []