gz_activemessaging 0.13.1

data/lib/activemessaging/message_sender.rb

@@ -0,0 +1,30 @@
+require 'logger'
+
+module ActiveMessaging
+
+  # This is a module so that we can send messages from (for example) web page controllers, or can receive a single message
+  module MessageSender
+
+    def self.included(included_by)
+      class << included_by
+        def publishes_to destination_name
+          ActiveMessaging::Gateway.find_destination(destination_name)
+        end
+
+        def receives_from destination_name
+          ActiveMessaging::Gateway.find_destination(destination_name)
+        end
+      end
+    end
+
+    def publish destination_name, message, headers={}, timeout=10
+      ActiveMessaging::Gateway.publish(destination_name, message, self.class, headers, timeout)
+    end
+
+    def receive destination_name, headers={}, timeout=10
+      ActiveMessaging::Gateway.receive(destination_name, self.class, headers, timeout)
+    end
+
+  end
+
+end

data/lib/activemessaging/named_base.rb

@@ -0,0 +1,54 @@
+#Adapter to rubigen / rails
+
+if defined?(Rails)
+  class NamedBase < Rails::Generator::NamedBase
+  end
+else
+  class NamedBase < RubiGen::Base
+    attr_reader   :name, :class_name, :singular_name, :plural_name
+    attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth
+    alias_method :file_name, :singular_name
+    alias_method :actions, :args
+  
+    def initialize(runtime_args, runtime_options={})
+      super
+    
+      base_name = self.args.first
+      assign_names!(base_name)
+    end
+  
+    protected
+  
+    def assign_names!(name)
+      @name = name
+      base_name, @class_path, @file_path, @class_nesting, @class_nesting_depth = extract_modules(@name)
+      @class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name)
+      if @class_nesting.empty?
+        @class_name = @class_name_without_nesting
+      else
+        @table_name = @class_nesting.underscore << "_" << @table_name
+        @class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
+      end
+    end
+
+    # Extract modules from filesystem-style or ruby-style path:
+    #   good/fun/stuff
+    #   Good::Fun::Stuff
+    # produce the same results.
+    def extract_modules(name)
+      modules = name.include?('/') ? name.split('/') : name.split('::')
+      name    = modules.pop
+      path    = modules.map { |m| m.underscore }
+      file_path = (path + [name.underscore]).join('/')
+      nesting = modules.map { |m| m.camelize }.join('::')
+      [name, path, file_path, nesting, modules.size]
+    end
+
+    def inflect_names(name)
+      camel  = name.camelize
+      under  = camel.underscore
+      plural = under.pluralize
+      [camel, under, plural]
+    end
+  end
+end

data/lib/activemessaging/processor.rb

@@ -0,0 +1,44 @@
+# 'abstract' base class for ActiveMessaging processor classes
+module ActiveMessaging
+
+  class Processor
+    include MessageSender
+    
+    attr_reader :message
+  
+    class<<self
+      def subscribes_to destination_name, headers={}
+        ActiveMessaging::Gateway.subscribe_to destination_name, self, headers
+      end
+    end
+
+    def logger()
+      @@logger ||= ActiveMessaging.logger
+    end
+    
+    def on_message(message)
+      raise NotImplementedError.new("Implement the on_message method in your own processor class that extends ActiveMessaging::Processor")
+    end
+
+    def on_error(exception)
+      raise exception
+    end
+    
+    # Bind the processor to the current message so that the processor could
+    # potentially access headers and other attributes of the message
+    def process!(message)
+      @message = message
+      return on_message(message.body)
+    rescue Object=>err
+      begin
+        on_error(err)
+      rescue ActiveMessaging::AbortMessageException => rpe
+        logger.error "Processor:process! - AbortMessageException caught."
+        raise rpe
+      rescue Object=>ex
+        logger.error "Processor:process! - error in on_error, will propagate no further: #{ex.message}\n\t#{ex.backtrace.join("\n\t")}"
+      end
+    end
+
+  end
+end

data/lib/activemessaging/railtie.rb

@@ -0,0 +1,26 @@
+require 'logger'
+require 'rails'
+require 'activemessaging'
+
+module ActiveMessaging
+  class Railtie < Rails::Railtie
+    
+    initializer 'activemessaging.initialize' do
+      
+      ActiveMessaging.load_activemessaging
+      
+      if defined? Rails
+        ActiveMessaging.logger.info "ActiveMessaging: Rails available: Adding dispatcher prepare callback."
+        ActionDispatch::Callbacks.to_prepare do
+          ActiveMessaging.reload_activemessaging
+        end
+      end
+
+    end
+
+    rake_tasks do
+      load "tasks/start_consumers.rake"
+    end
+    
+  end
+end

data/lib/activemessaging/test_helper.rb

@@ -0,0 +1,189 @@
+require 'test/unit'
+#require "#{File.dirname(__FILE__)}/trace_filter"
+
+
+module ActiveMessaging #:nodoc:
+  @@logger = nil
+
+  # def self.reload_activemessaging
+  # end
+
+  def self.logger
+    @@logger ||= MockLogger.new
+    @@logger
+  end
+  
+  class AbortMessageException < Exception #:nodoc:
+  end
+
+  class StopFilterException < Exception #:nodoc:
+  end
+
+  class Gateway
+    
+    def self.reset
+      unsubscribe
+      disconnect
+      @filters = []
+      @subscriptions = {}
+      @named_destinations = {}
+      @processor_groups = {}
+      @current_processor_group = nil
+      @connections = {}
+    end    
+  end
+  
+  module MessageSender
+    
+    @@__a13g_initialized__ = false
+    def publish_with_reset(destination_name, message, headers={}, timeout=10)
+      unless @@__a13g_initialized__
+        ActiveMessaging.reload_activemessaging 
+        @@__a13g_initialized__ = true
+      end
+      publish_without_reset(destination_name, message, headers, timeout)
+    end
+
+    alias_method_chain :publish, :reset
+    
+  end
+  
+  class TestMessage < ActiveMessaging::BaseMessage
+
+    def initialize(body="", headers={}, destination="")
+      super(body, nil, headers, destination)
+      @headers['destination'] = destination
+    end
+
+  end
+
+  module TestHelper
+    
+    # #Many thanks must go to the ActiveRecord fixture code
+    # #for showing how to properly alias setup and teardown
+    # def self.included(base)
+    #   base.extend(ClassMethods)
+    # 
+    #   class << base
+    #     alias_method_chain :method_added, :a13g
+    #   end
+    #   
+    # end
+    
+    # module ClassMethods
+    # 
+      # def method_added_with_a13g(method)
+      #   return if @__a13g_disable_method_added__
+      #   @__a13g_disable_method_added__ = true
+      #   
+      #   case method.to_s
+      #   when 'setup'
+      #     unless method_defined?(:setup_without_a13g)
+      #       alias_method :setup_without_a13g, :setup
+      #       define_method(:full_setup) do
+      #         setup_with_a13g
+      #         setup_without_a13g
+      #       end
+      #     end
+      #     alias_method :setup, :full_setup
+      #   when 'teardown'
+      #     unless method_defined?(:teardown_without_a13g)
+      #       alias_method :teardown_without_a13g, :teardown
+      #       define_method(:full_teardown) do
+      #         teardown_without_a13g
+      #         teardown_with_a13g
+      #       end
+      #     end
+      #     alias_method :teardown, :full_teardown
+      #   end
+      # 
+      #   method_added_without_a13g(method)
+      #   
+      #   @__a13g_disable_method_added__ = false
+      # end
+    # 
+    # end
+    
+    # def setup_with_a13g
+    #   ActiveMessaging.reload_activemessaging
+    # end
+    # 
+    # def teardown_with_a13g
+    #   ActiveMessaging::Gateway.reset
+    # end
+
+    def mock_publish destination, body, publisher=nil, headers={}
+      ActiveMessaging::Gateway.publish destination, body, publisher, headers
+    end
+
+    def assert_message destination, body
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Message for '#{destination}' with '#{body}' is not present.
+      Messages:
+      #{ActiveMessaging::Gateway.connection('default').all_messages.inspect}
+      EOF
+      assert ActiveMessaging::Gateway.connection.find_message(destination, body), error_message
+    end
+      
+    def assert_no_message_with destination, body
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Message for '#{destination}' with '#{body}' is present.
+      Messages:
+      #{ActiveMessaging::Gateway.connection('default').all_messages.inspect}
+      EOF
+      assert_nil ActiveMessaging::Gateway.connection('default').find_message(destination, body), error_message
+    end
+
+    def assert_no_messages destination
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Expected no messages.
+      Messages:
+      #{ActiveMessaging::Gateway.connection('default').all_messages.inspect}
+      EOF
+      assert_equal [], ActiveMessaging::Gateway.connection('default').all_messages, error_message
+    end
+
+    def assert_subscribed destination
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Not subscribed to #{destination}.
+      Subscriptions:
+      #{ActiveMessaging::Gateway.connection('default').subscriptions.inspect}
+      EOF
+      assert ActiveMessaging::Gateway.connection('default').find_subscription(destination), error_message
+    end
+
+    def assert_not_subscribed destination
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Subscribed to #{destination}.
+      Subscriptions:
+      #{ActiveMessaging::Gateway.connection('default').subscriptions.inspect}
+      EOF
+      assert_nil ActiveMessaging::Gateway.connection('default').find_subscription(destination), error_message
+    end
+    
+    def assert_has_messages destination
+      destination_name = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      No messages for #{destination_name}.
+      All messages:
+      #{ActiveMessaging::Gateway.connection('default').all_messages.inspect}
+      EOF
+      destination = ActiveMessaging::Gateway.connection('default').find_destination destination_name
+      assert !destination.nil? && !destination.messages.empty?, error_message
+    end
+  end
+  
+  class MockLogger
+    def error(*args) ; end
+    def warn(*args) ; end
+    def info(*args) ; end
+    def debug(*args) ; end
+  end
+
+end
+

data/lib/activemessaging/threaded_poller.rb

@@ -0,0 +1,234 @@
+# This owes no small debt to sidekiq for showing how to use celluloid for polling for messages.
+# https://github.com/mperham/sidekiq/blob/poller/lib/sidekiq/manager.rb
+if RUBY_VERSION.to_f >= 1.9 # Celluloid requires fibers support, which is not available on 1.8
+require 'celluloid'
+
+module ActiveMessaging
+
+  class ThreadedPoller
+
+    include Celluloid
+
+    # traps when any worker dies
+    trap_exit :died
+
+    attr_accessor :configuration, :receiver, :connection, :workers, :busy, :running, :pause
+
+    # 
+    # connection is a string, name of the connection from broker.yml to use for this threaded poller instance
+    # 
+    # configuration is a list of hashes
+    # each has describes a group of worker threads
+    # for each group, define what priorities those workers will process
+    #   [
+    #     {
+    #       :pool_size  => 1       # number of workers of this type
+    #       :priorities => [1,2,3] # what message priorities this thread will process
+    #     }
+    #   ]
+    # 
+    def initialize(connection='default', configuration={})
+      # default config is a pool size of 3 worker threads
+      self.configuration = configuration || [{:pool_size => 3}]
+      self.connection = connection
+      self.pause = 1
+    end
+
+    def start
+      logger.info "ActiveMessaging::ThreadedPoller start"
+
+      # these are workers ready to use
+      self.workers = []
+      
+      # these are workers already working
+      self.busy = []
+      
+      # this indicates if we are running or not, helps threads to stop gracefully
+      self.running = true
+      
+      # subscribe will create the connections based on subscriptions in processsors
+      # (you can't find or use the connection until it is created by calling this)
+      ActiveMessaging::Gateway.subscribe
+      
+      # create a message receiver actor, ony need one, using connection
+      receiver_connection = ActiveMessaging::Gateway.connection(connection)
+      self.receiver = MessageReceiver.new(current_actor, receiver_connection, pause)
+      
+      # start the workers based on the config
+      configuration.each do |c|
+        (c[:pool_size] || 1).times{ self.workers << Worker.new_link(current_actor, c) }
+      end
+
+      # once all workers are created, start them up
+      self.workers.each{|worker| receive(worker)}
+
+      # in debug level, log info about workers every 10 seconds
+      log_status
+    end
+
+    def stop
+      logger.info "ActiveMessaging::ThreadedPoller stop"
+      # indicates to all busy workers not to pick up another messages, but does not interrupt
+      # also indicates to the message receiver to stop getting more messages 
+      self.running = false
+
+      # tell each waiting worker to shut down.  Running ones will be allowed to finish
+      receiver.terminate! if receiver.alive?
+      logger.info "ActiveMessaging::ThreadedPoller receiver terminated"
+
+      workers.each { |w| w.terminate! if w.alive? }
+      logger.info "ActiveMessaging::ThreadedPoller workers terminated"
+
+
+      after(0) { signal(:shutdown) } if stopped?
+    end
+
+    # recursive method, uses celluloid 'after' to keep calling 
+    def log_status
+      return unless logger.debug?
+      logger.debug("ActiveMessaging::ThreadedPoller: conn:#{connection}, #{workers.count}, #{busy.count}, #{running}")
+      after(10){ log_status }
+    end
+
+    def receive(worker)
+      receiver.receive!(worker) if (receiver && running && worker)
+    end
+
+    def dispatch(message, worker)
+      workers.delete(worker)
+      busy << worker
+      worker.execute!(message)
+    end
+    
+    def executed(worker)
+      busy.delete(worker)
+
+      if running
+        workers << worker
+        receive(worker)
+      else
+        worker.terminate if worker.alive?
+        if busy.empty?
+          logger.info "all executed: signal stopped"
+          after(0) { signal(:shutdown) }
+        end
+      end
+    end
+
+    def died(worker, reason)
+      busy.delete(worker)
+
+      if running
+        logger.info "uh oh, #{worker.inspect} died because of #{reason.class}"
+        worker = Worker.new_link(current_actor)
+        workers << worker
+        receive(worker)
+      else
+        logger.info "check to see if busy is empty: #{busy.inspect}"
+        if busy.empty?
+          logger.info "all died: signal stopped"
+          after(0){ signal(:shutdown) }
+        end
+      end
+    end
+    
+    def stopped?
+      (!running && busy.empty?)
+    end
+
+    def inspect
+      "#<ThreadedPoller #{to_s}>"
+    end
+
+    def to_s
+      @str ||= "#{Process.pid}-#{Thread.current.object_id}:#{self.object_id}"
+    end
+
+    def logger; ActiveMessaging.logger; end
+
+  end
+
+  class MessageReceiver
+    include Celluloid
+
+    attr_accessor :poller, :connection, :pause
+
+    def initialize(poller, connection, pause=1)
+      logger.debug("MessageReceiver initialize: poller:#{poller}, connection:#{connection}, pause:#{pause}")
+      
+      raise "No connection found for '#{poller.connection}'" unless connection
+      
+      self.poller     = poller
+      self.connection = connection
+      self.pause      = pause
+    end
+
+    def receive(worker)
+      return unless poller.running
+
+      # logger.debug("***** MessageReceiver calling receive")
+      message = self.connection.receive(worker.options)
+      # logger.debug("***** MessageReceiver receive returned")
+
+      if message
+        logger.debug("ActiveMessaging::MessageReceiver.receive: message:'#{message.inspect}'")
+        poller.dispatch!(message, worker)
+      else
+        if (!poller || !poller.alive? || !poller.running)
+          logger.debug("ActiveMessaging::MessageReceiver.receive: terminate")
+          self.terminate
+        end
+        logger.debug("ActiveMessaging::MessageReceiver.receive: no message for worker #{worker.object_id}, retry in #{pause} sec")
+        after(pause) { receive(worker) }
+      end
+      
+    end
+
+    def inspect
+      "#<MessageReceiver #{to_s}>"
+    end
+
+    def to_s
+      @str ||= "#{Process.pid}-#{Thread.current.object_id}:#{self.object_id}"
+    end
+
+    def logger; ::ActiveMessaging.logger; end
+  end
+
+  class Worker
+    include Celluloid
+
+    attr_accessor :poller, :options
+
+    def initialize(poller, options)
+      self.poller = poller
+      self.options = options
+    end
+
+    def execute(message)
+      begin
+        ::ActiveMessaging::Gateway.dispatch(message)
+      rescue Object => err
+        logger.error("ActiveMessaging::Worker.execute error - #{err.inspect}")
+        abort(err)
+      ensure
+        ::ActiveRecord::Base.clear_active_connections! if defined?(::ActiveRecord)
+      end
+
+      poller.executed!(current_actor)
+    end
+
+    def inspect
+      "#<Worker #{to_s}>"
+    end
+
+    def to_s
+      @str ||= "#{Process.pid}-#{Thread.current.object_id}:#{self.object_id}"
+    end
+
+    def logger; ::ActiveMessaging.logger; end
+    
+  end
+
+end
+end # if RUBY_VERSION