activemessaging 0.9.0 → 0.10.0

data/README.md

@@ -0,0 +1,21 @@
+# Active Messaging
+
+ActiveMessaging is an attempt to bring the simplicity and elegance of rails development to the world of messaging. Messaging, (or event-driven architecture) is widely used for enterprise integration, with frameworks such as Java's JMS, and products such as ActiveMQ, Tibco, IBM MQSeries, etc.
+
+ActiveMessaging is a generic framework to ease using messaging, but is not tied to any particular messaging system - in fact, it now has support for Stomp, AMQP, beanstalk, Amazon Simple Queue Service (SQS), JMS (using StompConnect or direct on JRuby), WebSphere MQ, the all-Ruby ReliableMessaging, a mock 'test' adapter, and a 'synch' adapter for use in development that processes calls synchronously (of course) and so requires no broker or additional processes to be running. 
+
+Here's a sample of a processor class that handles incoming messages:
+
+    class HelloWorldProcessor < ActiveMessaging::Processor
+    	subscribes_to :hello_world
+    	def on_message(message)
+    		puts "received: " + message
+    	end
+    end
+
+
+# Support
+
+Best bet is the google groups mailing list:
+
+http://groups.google.com/group/activemessaging-discuss

data/Rakefile

@@ -33,6 +33,7 @@ begin
 
     # added
     gemspec.add_dependency('activesupport', '>= 1.0.0')
+    gemspec.add_dependency('celluloid')
     
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.9.0
+0.10.0

data/activemessaging.gemspec

@@ -4,19 +4,19 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{activemessaging}
-  s.version = "0.9.0"
+  s.name = "activemessaging"
+  s.version = "0.10.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jon Tirsen", "Andrew Kuklewicz", "Olle Jonsson", "Sylvain Perez", "Cliff Moon", "Uwe Kubosch"]
-  s.date = %q{2011-12-05}
-  s.description = %q{ActiveMessaging is an attempt to bring the simplicity and elegance of rails development to the world of messaging. Messaging, (or event-driven architecture) is widely used for enterprise integration, with frameworks such as Java's JMS, and products such as ActiveMQ, Tibco, IBM MQSeries, etc. Now supporting Rails 3 as of version 0.8.0.}
-  s.email = %q{activemessaging-discuss@googlegroups.com}
+  s.date = "2012-07-13"
+  s.description = "ActiveMessaging is an attempt to bring the simplicity and elegance of rails development to the world of messaging. Messaging, (or event-driven architecture) is widely used for enterprise integration, with frameworks such as Java's JMS, and products such as ActiveMQ, Tibco, IBM MQSeries, etc. Now supporting Rails 3 as of version 0.8.0."
+  s.email = "activemessaging-discuss@googlegroups.com"
   s.extra_rdoc_files = [
-    "README"
+    "README.md"
   ]
   s.files = [
-    "README",
+    "README.md",
     "Rakefile",
     "VERSION",
     "activemessaging.gemspec",
@@ -66,6 +66,7 @@ Gem::Specification.new do |s|
     "lib/activemessaging/processor.rb",
     "lib/activemessaging/railtie.rb",
     "lib/activemessaging/test_helper.rb",
+    "lib/activemessaging/threaded_poller.rb",
     "lib/activemessaging/trace_filter.rb",
     "lib/generators/active_messaging/install/USAGE",
     "lib/generators/active_messaging/install/install_generator.rb",
@@ -73,6 +74,7 @@ Gem::Specification.new do |s|
     "lib/generators/active_messaging/install/templates/broker.yml",
     "lib/generators/active_messaging/install/templates/poller",
     "lib/generators/active_messaging/install/templates/poller.rb",
+    "lib/generators/active_messaging/install/templates/threaded_poller",
     "lib/generators/active_messaging/processor/USAGE",
     "lib/generators/active_messaging/processor/processor_generator.rb",
     "lib/generators/active_messaging/processor/templates/messaging.rb",
@@ -93,33 +95,24 @@ Gem::Specification.new do |s|
     "test/test_helper.rb",
     "test/tracer_test.rb"
   ]
-  s.homepage = %q{http://github.com/kookster/activemessaging}
+  s.homepage = "http://github.com/kookster/activemessaging"
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.2}
-  s.summary = %q{Official activemessaging gem, now hosted on github.com/kookster. (kookster prefix temporary)}
-  s.test_files = [
-    "test/all_tests.rb",
-    "test/asqs_test.rb",
-    "test/config_test.rb",
-    "test/filter_test.rb",
-    "test/gateway_test.rb",
-    "test/jms_test.rb",
-    "test/reliable_msg_test.rb",
-    "test/stomp_test.rb",
-    "test/test_helper.rb",
-    "test/tracer_test.rb"
-  ]
+  s.rubygems_version = "1.8.22"
+  s.summary = "Official activemessaging gem, now hosted on github.com/kookster. (kookster prefix temporary)"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activesupport>, [">= 1.0.0"])
+      s.add_runtime_dependency(%q<celluloid>, [">= 0"])
     else
       s.add_dependency(%q<activesupport>, [">= 1.0.0"])
+      s.add_dependency(%q<celluloid>, [">= 0"])
     end
   else
     s.add_dependency(%q<activesupport>, [">= 1.0.0"])
+    s.add_dependency(%q<celluloid>, [">= 0"])
   end
 end
 

data/lib/activemessaging.rb

@@ -1,4 +1,5 @@
-require 'active_support'
+require 'logger'
+require 'active_support/all'
 require 'ostruct'
 
 if defined?(Rails::Railtie)
@@ -45,6 +46,7 @@ module ActiveMessaging
   def self.load_extensions
     require 'logger'
     require 'activemessaging/gateway'
+    require 'activemessaging/threaded_poller'
     require 'activemessaging/adapter'
     require 'activemessaging/message_sender'
     require 'activemessaging/processor'
@@ -66,8 +68,6 @@ module ActiveMessaging
     path = File.expand_path("#{app_root}/config/messaging.rb")
     begin
       load path
-    rescue MissingSourceFile
-      logger.error "ActiveMessaging: no '#{path}' file to load"
     rescue
       raise $!, " ActiveMessaging: problems trying to load '#{path}': \n\t#{$!.message}"
     end
@@ -126,7 +126,3 @@ module ActiveMessaging
   end
 
 end
-
-if !defined?(Rails::Railtie)
-  ActiveMessaging.load_activemessaging
-end

data/lib/activemessaging/adapters/amqp.rb

@@ -79,7 +79,7 @@ module ActiveMessaging
           client.server.send_frame(::Carrot::AMQP::Protocol::Basic::Reject.new(:delivery_tag => message.headers[:delivery_tag]))
         end
         
-        def receive
+        def receive(options={})
           while true 
             message = queue.pop(:ack => true)
             unless message.nil?

data/lib/activemessaging/adapters/asqs.rb

@@ -17,10 +17,10 @@ module ActiveMessaging
       class Connection < ActiveMessaging::Adapters::BaseConnection
         register :asqs
 
-        QUEUE_NAME_LENGTH = 1..80
-        MESSAGE_SIZE = 1..(8 * 1024)
-        VISIBILITY_TIMEOUT = 0..(24 * 60 * 60)
-        NUMBER_OF_MESSAGES = 1..255
+        QUEUE_NAME_LENGTH    = 1..80
+        MESSAGE_SIZE         = 1..(8 * 1024)
+        VISIBILITY_TIMEOUT   = 0..(24 * 60 * 60)
+        NUMBER_OF_MESSAGES   = 1..255
         GET_QUEUE_ATTRIBUTES = ['All', 'ApproximateNumberOfMessages', 'VisibilityTimeout']
         SET_QUEUE_ATTRIBUTES = ['VisibilityTimeout']
 
@@ -50,6 +50,7 @@ module ActiveMessaging
         
           #initialize the subscriptions and queues
           @subscriptions = {}
+          @queues_by_priority = {}
           @current_subscription = 0
           queues
         end
@@ -69,6 +70,10 @@ module ActiveMessaging
           else
             @subscriptions[queue.name] = Subscription.new(queue.name, message_headers)
           end
+          priority = @subscriptions[queue.name].priority
+
+          @queues_by_priority[priority] = [] unless @queues_by_priority.has_key?(priority)
+          @queues_by_priority[priority] << queue.name unless @queues_by_priority[priority].include?(queue.name)
         end
 
         # queue_name string, headers hash
@@ -76,7 +81,10 @@ module ActiveMessaging
         def unsubscribe queue_name, message_headers={}
           if @subscriptions[queue_name]
             @subscriptions[queue_name].remove
-            @subscriptions.delete(queue_name) if @subscriptions[queue_name].count <= 0
+            if @subscriptions[queue_name].count <= 0
+              sub = @subscriptions.delete(queue_name)
+              @queues_by_priority[sub.priority].delete(queue_name)
+            end
           end
         end
 
@@ -87,24 +95,60 @@ module ActiveMessaging
           send_messsage queue, message_body
         end
 
-        # receive a single message from any of the subscribed queues
-        # check each queue once, then sleep for poll_interval
-        def receive
-          raise "No subscriptions to receive messages from." if (@subscriptions.nil? || @subscriptions.empty?)
-          start = @current_subscription
-          while true
-            # puts "calling receive..."
-            @current_subscription = ((@current_subscription < @subscriptions.length-1) ? @current_subscription + 1 : 0)
-            sleep poll_interval if (@current_subscription == start)
-            queue_name = @subscriptions.keys.sort[@current_subscription]
-            queue = queues[queue_name]
-            subscription = @subscriptions[queue_name]
-            unless queue.nil?
-              messages = retrieve_messsages queue, 1, subscription.headers[:visibility_timeout]
-              return messages[0] unless (messages.nil? or messages.empty? or messages[0].nil?)
+        #  new receive respects priorities
+        def receive(options={})
+          message = nil
+
+          only_priorities = options[:priorities]
+
+          # loop through the priorities
+          @queues_by_priority.keys.sort.each do |priority|
+
+            # skip this priority if there is a list, and it is not in the list
+            next if only_priorities && !only_priorities.include?(priority.to_i)
+
+            # puts " - priority: #{priority}"
+            # loop through queues for the priority in random order each time
+            @queues_by_priority[priority].shuffle.each do |queue_name|
+              # puts "   - queue_name: #{queue_name}"
+              queue = queues[queue_name]
+              subscription = @subscriptions[queue_name]
+
+              next if queue.nil? || subscription.nil?
+              messages = retrieve_messsages(queue, 1, subscription.headers[:visibility_timeout])
+              
+              if (messages && !messages.empty?)
+                message = messages[0]
+              end
+
+              break if message
             end
+
+            break if message
           end
-        end
+
+          # puts " - message: #{message}"
+          message
+        end
+
+        # # receive a single message from any of the subscribed queues
+        # # check each queue once, then sleep for poll_interval
+        # def receive
+        #   raise "No subscriptions to receive messages from." if (@subscriptions.nil? || @subscriptions.empty?)
+        #   start = @current_subscription
+        #   while true
+        #     # puts "calling receive..."
+        #     @current_subscription = ((@current_subscription < @subscriptions.length-1) ? @current_subscription + 1 : 0)
+        #     sleep poll_interval if (@current_subscription == start)
+        #     queue_name = @subscriptions.keys.sort[@current_subscription]
+        #     queue = queues[queue_name]
+        #     subscription = @subscriptions[queue_name]
+        #     unless queue.nil?
+        #       messages = retrieve_messsages queue, 1, subscription.headers[:visibility_timeout]
+        #       return messages[0] unless (messages.nil? or messages.empty? or messages[0].nil?)
+        #     end
+        #   end
+        # end
 
         def received message, headers={}
           begin
@@ -125,7 +169,7 @@ module ActiveMessaging
         def create_queue(name)
           validate_new_queue name
       		response = make_request('CreateQueue', nil, {'QueueName'=>name})
-          add_queue response.get_text("//QueueUrl") unless response.nil?
+          add_queue(response.get_text("//QueueUrl")) unless response.nil?
         end      	
 
         def delete_queue queue
@@ -264,7 +308,9 @@ module ActiveMessaging
 
         def get_or_create_queue queue_name
           qs = queues
-          qs.has_key?(queue_name) ? qs[queue_name] : create_queue(queue_name)
+          q = qs.has_key?(queue_name) ? qs[queue_name] : create_queue(queue_name)
+          raise "could not get or create queue: #{queue_name}" unless q
+          q
         end
 
         def queues
@@ -359,9 +405,10 @@ module ActiveMessaging
       end
 
       class Subscription
-        attr_accessor :name, :headers, :count
+        attr_accessor :destination, :headers, :count, :priority
       
         def initialize(destination, headers={}, count=1)
+          @priority = headers.delete(:priority) || 1001
           @destination, @headers, @count = destination, headers, count
         end
       

data/lib/activemessaging/adapters/base.rb

@@ -39,7 +39,8 @@ module ActiveMessaging
 
       # receive a single message from any of the subscribed destinations
       # check each destination once, then sleep for poll_interval
-      def receive
+      # adding options,optionally, so a poller can get certain messages (e.g. by priority)
+      def receive(options={})
       end
 
       # called after a message is successfully received and processed

data/lib/activemessaging/adapters/beanstalk.rb

@@ -46,7 +46,7 @@ module ActiveMessaging
           @connection.put(message, priority, delay, ttr)
         end
         
-        def receive
+        def receive(options={})
           message = @connection.reserve
           Beanstalk::Message.new message
         end

data/lib/activemessaging/adapters/jms.rb

@@ -84,22 +84,24 @@ module ActiveMessaging
           end
           producer.send message
         end
-        
-        def receive_any
-          @consumers.find do |k, c|
-            message = c.receive(1)
-            return condition_message(message) unless message.nil?
-          end
+
+        def receive(options={})
+          queue_name = options[:queue_name]
+          headers = options[:headers] || {}
+          receive_message(queue_name, headers)
         end
-        
-        def receive queue_name=nil, headers={}
+
+        def receive_message(queue_name=nil, headers={})
           if queue_name.nil?
-            receive_any
+            @consumers.find do |k, c|
+              message = c.receive(1)
+              return condition_message(message) unless message.nil?
+            end
           else
-            consumer = subscribe queue_name, headers
+            consumer = subscribe(queue_name, headers)
             message = consumer.receive(1)
-            unsubscribe queue_name, headers
-            condition_message message
+            unsubscribe(queue_name, headers)
+            condition_message(message)
           end
         end
         

data/lib/activemessaging/adapters/reliable_msg.rb

@@ -89,7 +89,7 @@ module ActiveMessaging
 
       # receive a single message from any of the subscribed destinations
       # check each destination once, then sleep for poll_interval
-      def receive
+      def receive(options={})
 
         raise "No subscriptions to receive messages from." if (subscriptions.nil? || subscriptions.empty?)
         start = current_subscription

data/lib/activemessaging/adapters/stomp.rb

@@ -73,7 +73,7 @@ module ActiveMessaging
 
         # receive a single message from any of the subscribed destinations
         # check each destination once, then sleep for poll_interval
-        def receive
+        def receive(options={})
           m = @stomp_connection.receive
           Message.new(m) if m
         end

data/lib/activemessaging/adapters/test.rb

@@ -44,7 +44,7 @@ module ActiveMessaging
           destination.send Message.new(message_body, nil, message_headers, destination_name)
         end
         
-        def receive
+        def receive(options={})
           destination = @destinations.find do |q|
             find_subscription(q.name) && !q.empty?
           end

data/lib/activemessaging/adapters/wmq.rb

@@ -49,7 +49,7 @@ module ActiveMessaging
         end
 
         # Receive method needed by a13g
-        def receive
+        def receive(options={})
           raise "No subscription to receive messages from" if (@queue_names.nil? || @queue_names.empty?)
           start = @current_queue
           while true

data/lib/activemessaging/gateway.rb

@@ -1,25 +1,28 @@
 require 'yaml'
 require 'ostruct'
 require 'erb'
+require 'thread'
 
 module ActiveMessaging
 
   class Gateway
-    cattr_accessor :adapters, :subscriptions, :named_destinations, :filters, :processor_groups, :connections
-    @@adapters = {}
-    @@subscriptions = {}
-    @@named_destinations = {}
-    @@filters = []
-    @@connections = {}
-    @@processor_groups = {}
-    @@current_processor_group = nil
+ 
+    @adapters = {}
+    @subscriptions = {}
+    @named_destinations = {}
+    @filters = []
+    @connections = {}
+    @processor_groups = {}
+    @current_processor_group = nil
 
     # these are used to manage the running connection threads
-    @@running = true
-    @@connection_threads = {}
-    @@guard = Mutex.new
- 
-    class <<self
+    @running = true
+    @connection_threads = {}
+    @guard = Mutex.new
+
+    class << self
+
+      attr_accessor :adapters, :subscriptions, :named_destinations, :filters, :processor_groups, :connections
 
       # Starts up an message listener to start polling for messages on each configured connection, and dispatching processing
       def start
@@ -28,9 +31,9 @@ module ActiveMessaging
         subscribe
 
         # for each connection, start a thread
-        @@connections.each do |name, conn|
-          @@connection_threads[name] = Thread.start do
-            while @@running
+        @connections.each do |name, conn|
+          @connection_threads[name] = Thread.start do
+            while @running
               begin
                 Thread.current[:message] = nil
                 Thread.current[:message] = conn.receive
@@ -42,7 +45,11 @@ module ActiveMessaging
               rescue Object=>exception
                 ActiveMessaging.logger.error "ActiveMessaging: thread[#{name}]: Exception from connection.receive: #{exception.message}\n" + exception.backtrace.join("\n\t")
               ensure
-                dispatch Thread.current[:message] if Thread.current[:message]
+                if Thread.current[:message]
+                  @guard.synchronize {
+                    dispatch Thread.current[:message]
+                  }
+                end
                 Thread.current[:message] = nil
               end
               Thread.pass
@@ -51,11 +58,11 @@ module ActiveMessaging
           end
         end
         
-        while @@running
+        while @running
           trap("TERM", "EXIT")
           living = false
-          @@connection_threads.each { |name, thread| living ||=  thread.alive? }
-          @@running = living
+          @connection_threads.each { |name, thread| living ||=  thread.alive? }
+          @running = living
           sleep 1
         end
         ActiveMessaging.logger.error "All connection threads have died..."
@@ -72,14 +79,14 @@ module ActiveMessaging
       
       def stop
         # first tell the threads to stop their looping, so they'll stop when next complete a receive/dispatch cycle
-        @@running = false
+        @running = false
         
         # if they are dispatching (i.e. !thread[:message].nil?), wait for them to finish
         # if they are receiving (i.e. thread[:message].nil?), stop them by raising exception
         dispatching = true
         while dispatching
           dispatching = false
-          @@connection_threads.each do |name, thread|
+          @connection_threads.each do |name, thread|
             if thread[:message]
               dispatching = true
               # if thread got killed, but dispatch not done, try it again
@@ -109,15 +116,15 @@ module ActiveMessaging
       end
       
       def connection broker_name='default'
-        return @@connections[broker_name] if @@connections.has_key?(broker_name)
+        return @connections[broker_name] if @connections.has_key?(broker_name)
         config = load_connection_configuration(broker_name)
         adapter_class = Gateway.adapters[config[:adapter]]
         raise "Unknown messaging adapter #{config[:adapter].inspect}!" if adapter_class.nil?
-        @@connections[broker_name] = adapter_class.new(config)
+        @connections[broker_name] = adapter_class.new(config)
       end
 
       def register_adapter adapter_name, adapter_class
-        adapters[adapter_name] = adapter_class
+        Gateway.adapters[adapter_name] = adapter_class
       end
       
       def filter filter, options = {}
@@ -134,8 +141,8 @@ module ActiveMessaging
       end
 
       def disconnect
-        @@connections.each { |key,connection| connection.disconnect }
-        @@connections = {}
+        @connections.each { |key,connection| connection.disconnect }
+        @connections = {}
       end
 
       def execute_filter_chain(direction, message, details={})
@@ -199,19 +206,15 @@ module ActiveMessaging
       end
       
       def dispatch(message)
-        @@guard.synchronize {
-          begin
-            prepare_application
-            _dispatch(message)
-          rescue Object => exc
-            ActiveMessaging.logger.error "Dispatch exception: #{exc}"
-            ActiveMessaging.logger.error exc.backtrace.join("\n\t")
-            raise exc
-          ensure
-            ActiveMessaging.logger.flush rescue nil
-            reset_application
-          end
-        }
+        prepare_application
+        _dispatch(message)
+      rescue Object => exc
+        ActiveMessaging.logger.error "Dispatch exception: #{exc}"
+        ActiveMessaging.logger.error exc.backtrace.join("\n\t")
+        raise exc
+      ensure
+        ActiveMessaging.logger.flush rescue nil
+        reset_application
       end
 
       def _dispatch(message)
@@ -279,7 +282,7 @@ module ActiveMessaging
         proc_name = processor.name.underscore
         proc_sym = processor.name.underscore.to_sym
         if (!current_processor_group || processor_groups[current_processor_group].include?(proc_sym))
-          @@subscriptions["#{proc_name}:#{destination_name}"]= Subscription.new(find_destination(destination_name), processor, headers)
+          @subscriptions["#{proc_name}:#{destination_name}"]= Subscription.new(find_destination(destination_name), processor, headers)
         end
       end
 
@@ -335,13 +338,13 @@ module ActiveMessaging
       end
 
       def current_processor_group
-        if ARGV.length > 0 && !@@current_processor_group
+        if ARGV.length > 0 && !@current_processor_group
           ARGV.each {|arg|
             pair = arg.split('=')
             if pair[0] == 'process-group'
               group_sym = pair[1].to_sym
               if processor_groups.has_key? group_sym
-                @@current_processor_group = group_sym
+                @current_processor_group = group_sym
               else
                 ActiveMessaging.logger.error "Unrecognized process-group."
                 ActiveMessaging.logger.error "You specified process-group #{pair[1]}, make sure this is specified in config/messaging.rb"
@@ -353,7 +356,7 @@ module ActiveMessaging
             end
           }
         end
-        @@current_processor_group
+        @current_processor_group
       end
       
       def load_connection_configuration(label='default')

data/lib/activemessaging/threaded_poller.rb

@@ -0,0 +1,191 @@
+# still working on prioritized worker requests
+
+
+# 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
+
+require 'celluloid'
+
+module ActiveMessaging
+
+  class ThreadedPoller
+
+    include Celluloid
+
+    # traps when any worker dies
+    trap_exit :died
+
+    attr_accessor :configuration, :receiver, :connection, :workers, :busy, :running
+
+    # 
+    # 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
+    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)
+      
+      # 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
+      workers.each { |w| w.terminate if w.alive? }
+    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"
+          self.terminate if alive?
+        end
+      end
+    end
+
+    def died(worker, reason)
+      logger.info "uh oh, #{worker.inspect} died because of #{reason.class}"
+      busy.delete(worker)
+
+      if running
+        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){ self.terminate } if alive?
+        end
+      end
+    end
+    
+    def stopped?
+      !alive? || (!running && busy.empty?)
+    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
+
+      message = self.connection.receive(worker.options)
+
+      if message
+        logger.debug("ActiveMessaging::MessageReceiver.receive: message:'#{message.inspect}'")
+        poller.dispatch!(message, worker)
+      else
+        self.terminate if !poller.running && alive?  
+        logger.debug("ActiveMessaging::MessageReceiver.receive: no message, retry in #{pause} sec")
+        after(pause) { receive(worker) }
+      end
+      
+    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)
+      ActiveMessaging::Gateway.dispatch(message)
+      poller.executed!(current_actor)
+    end
+
+    def logger; ActiveMessaging.logger; end
+    
+  end
+
+end

data/lib/generators/active_messaging/install/install_generator.rb

@@ -12,7 +12,12 @@ module ActiveMessaging
       template "poller", "script/#{poller_name}"
       chmod("script/#{poller_name}", 0755)
     end
-    
+
+    def copy_threaded_poller
+      template "threaded_poller", "script/threaded_#{poller_name}"
+      chmod("script/threaded_#{poller_name}", 0755)
+    end
+
     def copy_poller_rb
       copy_file "poller.rb", "lib/#{poller_name}.rb"
     end

data/lib/generators/active_messaging/install/templates/poller.rb

@@ -3,25 +3,20 @@
 STDOUT.sync = true; STDOUT.flush
 STDERR.sync = true; STDERR.flush
 
-#Try to Load Merb
-merb_init_file = File.expand_path(File.dirname(__FILE__)+'/../config/merb_init')
-if File.exists? merb_init_file
-  require File.expand_path(File.dirname(__FILE__)+'/../config/boot')
-  #need this because of the CWD
-  Merb.root = MERB_ROOT
-  require merb_init_file
+app_root = ENV['APP_ROOT'] || File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+application_file = File.join(app_root, 'config', 'environment.rb')
+
+if File.exist?(application_file)
+  load application_file
 else
-  # Load Rails
-  RAILS_ROOT=File.expand_path(File.join(File.dirname(__FILE__), '..'))
-  require File.join(RAILS_ROOT, 'config', 'boot')
-  require File.join(RAILS_ROOT, 'config', 'environment')
+  raise "#{application_file} does not exist!"
 end
 
-require 'active_support'
-require 'activemessaging'
+Rails.logger = Logger.new(STDOUT)
+ActiveMessaging.logger = Rails.logger
 
-# Load ActiveMessaging processors
-#ActiveMessaging::load_processors
+# Load ActiveMessaging
+ActiveMessaging::load_processors
 
 # Start it up!
 ActiveMessaging::start

data/lib/generators/active_messaging/install/templates/threaded_poller

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+# The threaded poller will use celluloid to generate many threads for a single poller process to handle messages
+# Yes, I absolutely looked at the sidekiq manager code, and this code is very very similar
+# This script also shows how to use the poller without loading Rails, though it loads the app lib directory
+# this is tested on 1.9.3, and rails 3+
+
+# Make sure stdout and stderr write out without delay for using with daemon like scripts
+STDOUT.sync = true; STDOUT.flush
+STDERR.sync = true; STDERR.flush
+
+# we're not going to load rails, but activemessaging does expect there to be an app root
+# this goes back to when it was used in both rails or merb, but work with just not loading a framework
+app_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+ENV['APP_ROOT'] ||= app_root
+
+# minimal requirements, other requires are in the lib
+require 'rubygems'
+require 'bundler/setup'
+
+# load the app lib directory
+lib_path = File.dirname("#{app_root}/lib")
+$:.unshift(lib_path)
+Dir["#{lib_path}/**/*.rb"].each {|file| require file unless file.match(/poller\.rb/) }
+
+# require and load activemessaging
+require 'activemessaging'
+ActiveMessaging.load_activemessaging
+
+# configure the connection (there can be multiple defined in broker.yml) and number of threads
+connection_name = 'default'
+configuration   = [{:pool_size => 3}]
+
+# start it up!
+begin
+  trap("TERM", "EXIT")
+  @poller = ActiveMessaging::ThreadedPoller.new(connection_name, configuration)
+  @poller.start!
+  sleep
+rescue Interrupt
+  puts "-- Interrupt --"
+  @poller.stop!
+  @poller.wait(:shutdown)
+  exit(0)
+end

metadata

@@ -1,15 +1,10 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: activemessaging
-version: !ruby/object:Gem::Version 
-  hash: 59
+version: !ruby/object:Gem::Version
+  version: 0.10.0
   prerelease: 
-  segments: 
-  - 0
-  - 9
-  - 0
-  version: 0.9.0
 platform: ruby
-authors: 
+authors:
 - Jon Tirsen
 - Andrew Kuklewicz
 - Olle Jonsson
@@ -19,36 +14,52 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-12-05 00:00:00 -05:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 0
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-description: ActiveMessaging is an attempt to bring the simplicity and elegance of rails development to the world of messaging. Messaging, (or event-driven architecture) is widely used for enterprise integration, with frameworks such as Java's JMS, and products such as ActiveMQ, Tibco, IBM MQSeries, etc. Now supporting Rails 3 as of version 0.8.0.
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ActiveMessaging is an attempt to bring the simplicity and elegance of
+  rails development to the world of messaging. Messaging, (or event-driven architecture)
+  is widely used for enterprise integration, with frameworks such as Java's JMS, and
+  products such as ActiveMQ, Tibco, IBM MQSeries, etc. Now supporting Rails 3 as of
+  version 0.8.0.
 email: activemessaging-discuss@googlegroups.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README
-files: 
-- README
+extra_rdoc_files:
+- README.md
+files:
+- README.md
 - Rakefile
 - VERSION
 - activemessaging.gemspec
@@ -98,6 +109,7 @@ files:
 - lib/activemessaging/processor.rb
 - lib/activemessaging/railtie.rb
 - lib/activemessaging/test_helper.rb
+- lib/activemessaging/threaded_poller.rb
 - lib/activemessaging/trace_filter.rb
 - lib/generators/active_messaging/install/USAGE
 - lib/generators/active_messaging/install/install_generator.rb
@@ -105,6 +117,7 @@ files:
 - lib/generators/active_messaging/install/templates/broker.yml
 - lib/generators/active_messaging/install/templates/poller
 - lib/generators/active_messaging/install/templates/poller.rb
+- lib/generators/active_messaging/install/templates/threaded_poller
 - lib/generators/active_messaging/processor/USAGE
 - lib/generators/active_messaging/processor/processor_generator.rb
 - lib/generators/active_messaging/processor/templates/messaging.rb
@@ -124,48 +137,29 @@ files:
 - test/stomp_test.rb
 - test/test_helper.rb
 - test/tracer_test.rb
-has_rdoc: true
 homepage: http://github.com/kookster/activemessaging
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.4.2
+rubygems_version: 1.8.22
 signing_key: 
 specification_version: 3
-summary: Official activemessaging gem, now hosted on github.com/kookster. (kookster prefix temporary)
-test_files: 
-- test/all_tests.rb
-- test/asqs_test.rb
-- test/config_test.rb
-- test/filter_test.rb
-- test/gateway_test.rb
-- test/jms_test.rb
-- test/reliable_msg_test.rb
-- test/stomp_test.rb
-- test/test_helper.rb
-- test/tracer_test.rb
+summary: Official activemessaging gem, now hosted on github.com/kookster. (kookster
+  prefix temporary)
+test_files: []

data/README

@@ -1,28 +0,0 @@
-ActiveMessaging is an attempt to bring the simplicity and elegance of rails development to the world of messaging. Messaging, (or event-driven architecture) is widely used for enterprise integration, with frameworks such as Java's JMS, and products such as ActiveMQ, Tibco, IBM MQSeries, etc.
-
-ActiveMessaging is a generic framework to ease using messaging, but is not tied to any particular messaging system - in fact, it now has support for Stomp, Amazon Simple Queue Service (SQS), Beanstalk, JMS (using StompConnect or [JMSWithJRuby direct on JRuby]), WebSphere MQ, and the all-Ruby ReliableMessaging.
-
-Here's a sample of a processor class that handles incoming messages:
-
-    class HelloWorldProcessor < ActiveMessaging::Processor
-
-    subscribes_to :hello_world
-
-    def on_message(message)
-    puts "received: " + message
-    end
-
-    end
-
-
-h1. Support
-
-Best bet is the google groups mailing list:
-
-http://groups.google.com/group/activemessaging-discuss
-
-h1. Fork Details
-
-This fork adds the ability to specify a dead letter queue prefix so instead of all messages going to 1 dead letter queue, each message will go to a dead letter queue that is based on the deadLetterQueuePrefix configuration property and the originating queue. 
-
-For example, if you specific a deadLetterQueuePrefix of "DLQ." in your broker.yml and the originating queue is /queue/myqueue then the dead letter queue will be /queue/DLQ.myqueue