rosetta_queue 0.4.0

data/lib/rosetta_queue/adapters/base.rb

@@ -0,0 +1,27 @@
+module RosettaQueue
+  module Gateway
+
+    class BaseAdapter
+
+      protected
+
+        def options_for(message_handler)
+          (message_handler.options_hash) || {}
+        end
+
+        def destination_for(message_handler)
+          raise DestinationNotFound.new("Missing destination on message handler #{message_handler.inspect}.") unless message_handler.destination
+          @dest ||= Destinations.lookup(message_handler.destination.to_sym)
+        end
+
+        def filter_receiving(msg)
+          Filters.process_receiving(msg)
+        end
+
+        def filter_sending(msg)
+          Filters.process_sending(msg)
+        end
+
+    end
+  end
+end

data/lib/rosetta_queue/adapters/beanstalk.rb

@@ -0,0 +1,56 @@
+require 'beanstalk-client'
+
+module RosettaQueue
+  module Gateway
+
+    class BeanstalkAdapter < BaseAdapter
+
+      def ack(msg)
+        @conn.ack(msg.headers["message-id"])
+      end
+
+      def initialize(adapter_settings = {})
+        @host, @port = adapter_settings[:host], adapter_settings[:port]
+        @conn = Beanstalk::Pool.new(["#{@host}:#{@port}"])
+      end
+
+      def disconnect; end
+
+      # TODO: support options[:timeout] ?
+      def receive(options=nil)
+        msg = @conn.reserve
+        msg.delete
+        msg
+      end
+
+      def receive_once(destination=nil, opts={})
+        receive.body
+      end
+
+      def receive_with(message_handler)
+        # Note that, while we call destination_for (to comply with
+        # Rosetta's generic specs), beanstalk doesn't actually support
+        # destinations. This is just for compatibility.
+        destination = destination_for(message_handler)
+
+        running do
+          msg = receive.body
+          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+          message_handler.handle_message(msg)
+        end
+      end
+
+      def send_message(destination, message, options)
+        RosettaQueue.logger.info("Publishing to #{destination} :: #{message}")
+        @conn.put(message)
+      end
+
+      private
+
+        def running(&block)
+          loop(&block)
+        end
+
+    end
+  end
+end

data/lib/rosetta_queue/adapters/fake.rb

@@ -0,0 +1,26 @@
+module RosettaQueue
+  module Gateway
+
+    class FakeAdapter
+
+      def initialize
+        @messages = []
+      end
+
+      def send_message(queue, message, headers)
+        @messages << {'queue' => queue, 'message' => RosettaQueue::Filters::process_receiving(message), 'headers' => headers}
+      end
+
+      def messages_sent_to(queue)
+        (queue ? @messages.select{|message| message['queue'] == queue} : @messages).map{|m| m['message']}
+      end
+
+      def queues
+        @messages.map {|message| message['queue']}
+      end
+
+    end
+
+  end
+
+end

data/lib/rosetta_queue/adapters/null.rb

@@ -0,0 +1,57 @@
+module RosettaQueue
+  module Gateway
+
+    # The null adapter lets all send messages enter into the ether and so is ideal for modes
+    # when you do not want to incur the overhead of a real adapter.  You can not consume with
+    # this adapter however.
+    #
+    # In your RosettaQueue definition block, and your using rails, you could base your adapter type on Rails.env:
+    #
+    # RosettaQueue::Adapter.define do |a|
+    #   if Rails.env == 'production' || ENV["RUNNING_STORIES"] == "true"
+    #     a.user = ""
+    #     a.password = ""
+    #     a.host = "localhost"
+    #     a.port = 61613
+    #     a.type = "stomp"
+    #   else
+    #     a.type = "null"
+    #   end
+    # end
+    #
+    # (if you follow this example and are using stories be sure
+    # to set ENV["RUNNING_STORIES"] = "true" in your helper.rb or env.rb file)
+    class NullAdapter
+
+      def initialize(adapter_settings)
+        # no-op
+      end
+
+      def disconnect
+        # no-op
+      end
+
+      def receive
+        raise "Null Adpater is in use, you can not consume messages!"
+      end
+
+      def receive_with(message_handler)
+        raise "Null Adpater is in use, you can not consume messages!"
+      end
+
+      def send_message(queue, message, options)
+        # no-op
+      end
+
+      def subscribe(queue, options)
+        # no-op
+      end
+
+      def unsubscribe(queue)
+        # no-op
+      end
+
+
+    end
+  end
+end

data/lib/rosetta_queue/adapters/stomp.rb

@@ -0,0 +1,88 @@
+require 'stomp'
+
+module RosettaQueue
+  module Gateway
+
+    class StompAdapter < BaseAdapter
+
+      def ack(msg)
+        raise AdapterException, "Unable to ack client because message-id is blank.  Are your message handler options correct? (i.e., :ack => 'client')" if msg.headers["message-id"].nil?
+        @conn.ack(msg.headers["message-id"])
+      end
+
+      def initialize(adapter_settings = {})
+        raise AdapterException, "Missing adapter settings" if adapter_settings.empty?
+        @conn = Stomp::Connection.open(adapter_settings[:user],
+                                       adapter_settings[:password],
+                                       adapter_settings[:host],
+                                       adapter_settings[:port],
+                                       true)
+      end
+
+      def disconnect(message_handler)
+        unsubscribe(destination_for(message_handler))
+        @conn.disconnect
+      end
+
+      def receive(options)
+        msg = @conn.receive
+        ack(msg) unless options[:ack].nil?
+        msg
+      end
+
+      def receive_once(destination, opts)
+        subscribe(destination, opts)
+        msg = receive(opts).body
+        unsubscribe(destination)
+        RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+        filter_receiving(msg)
+      end
+
+      def receive_with(message_handler)
+        options = options_for(message_handler)
+        destination = destination_for(message_handler)
+        @conn.subscribe(destination, options)
+
+        running do
+          msg = receive(options).body
+          Thread.current[:processing] = true
+          RosettaQueue.logger.info("Receiving from #{destination} :: #{msg}")
+          message_handler.handle_message(msg)
+          Thread.current[:processing] = false
+        end
+      end
+
+      def send_message(destination, message, options)
+        RosettaQueue.logger.info("Publishing to #{destination} :: #{message}")
+        @conn.send(destination, message, options)
+      end
+
+      def subscribe(destination, options)
+        @conn.subscribe(destination, options)
+      end
+
+      def unsubscribe(destination)
+        @conn.unsubscribe(destination)
+      end
+
+      private
+
+        def running(&block)
+          loop(&block)
+        end
+
+    end
+
+    class StompAdapterProxy
+
+      def initialize(adapter, msg)
+        @adapter, @msg = adapter, msg
+      end
+
+      def ack
+        @adapter.ack(@msg)
+      end
+    end
+
+  end
+end

data/lib/rosetta_queue/base.rb

@@ -0,0 +1,15 @@
+module RosettaQueue
+
+  class Base
+
+    def disconnect
+      connection.disconnect(@message_handler)
+    end
+
+    protected
+     def connection
+       @conn ||= Adapter.instance
+     end
+
+  end
+end

data/lib/rosetta_queue/consumer.rb

@@ -0,0 +1,30 @@
+module RosettaQueue
+  class Consumer < Base
+
+    def self.receive(destination, options = {})
+      RosettaQueue::Adapter.instance.receive_once(Destinations.lookup(destination), options)
+
+      rescue Exception=>e
+        RosettaQueue.logger.error("Caught exception in Consumer.receive: #{$!}\n" + e.backtrace.join("\n\t"))
+    end
+
+    def self.delete(destination, options={})
+      RosettaQueue::Adapter.instance.delete(Destinations.lookup(destination), options)
+
+      rescue Exception=>e
+        RosettaQueue.logger.error("Caught exception in Consumer.delete: #{$!}\n" + e.backtrace.join("\n\t"))
+    end
+
+    def initialize(message_handler)
+      @message_handler = message_handler
+    end
+
+    def receive
+      connection.receive_with(@message_handler)
+
+      rescue Exception=>e
+        RosettaQueue.logger.error("Caught exception in Consumer#receive: #{$!}\n" + e.backtrace.join("\n\t"))
+    end
+
+  end
+end

data/lib/rosetta_queue/consumer_managers/base.rb

@@ -0,0 +1,24 @@
+module RosettaQueue
+
+  class BaseManager
+    attr_reader :consumers
+
+    class << self
+      def create
+        manager = self.new
+        yield manager
+        manager
+      end
+    end
+
+    def initialize
+      @consumers  = {}
+    end
+
+    def add(message_handler)
+      key = message_handler.class.to_s.underscore.to_sym
+      @consumers[key] = Consumer.new(message_handler)
+    end
+
+  end
+end

data/lib/rosetta_queue/consumer_managers/evented.rb

@@ -0,0 +1,43 @@
+require 'rosetta_queue/consumer_managers/base'
+require 'mq'
+
+module RosettaQueue
+
+  class EventedManager < BaseManager
+
+    def start
+      EM.run {
+        trap_interruptions
+
+        begin
+          @consumers.each do |key, consumer|
+            RosettaQueue.logger.info("Running consumer #{key} in event machine...")
+            consumer.receive
+          end
+        rescue Exception => e
+          RosettaQueue.logger.error("Exception thrown: #{$!}\n" + e.backtrace.join("\n\t"))
+        end
+      }
+    end
+
+    def stop
+      RosettaQueue.logger.info("Shutting down event machine...")
+      EM.stop
+    end
+
+    private
+
+      def trap_interruptions
+        trap("INT") {
+          RosettaQueue.logger.warn("Interrupt received.  Shutting down...")
+          EM.stop
+        }
+
+        trap("TERM") {
+          RosettaQueue.logger.warn("Interrupt received.  Shutting down...")
+          EM.stop
+        }
+      end
+
+  end
+end

data/lib/rosetta_queue/consumer_managers/threaded.rb

@@ -0,0 +1,94 @@
+require 'rosetta_queue/consumer_managers/base'
+
+module RosettaQueue
+  class ThreadedManager < BaseManager
+
+    def initialize
+      @threads    = {}
+      @running    = true
+      @processing = true
+      super
+    end
+
+    def start
+      start_threads
+      join_threads
+      monitor_threads
+    end
+
+    def stop
+      stop_threads
+    end
+
+  private
+
+    def join_threads
+      @threads.each { |thread| thread.join }
+    end
+
+    def shutdown_requested
+      RosettaQueue.logger.error "Shutdown requested, starting to prune threads..."
+
+      while @threads.any? { |n, t| t.alive? }
+        RosettaQueue.logger.info "Calling stop_threads"
+        stop_threads
+        sleep 5
+      end
+    end
+
+    def monitor_threads
+      while @running
+        trap("TERM") { shutdown_requested }
+        trap("INT")  { shutdown_requested }
+        living = false
+        @threads.each { |name, thread| living ||= thread.alive? }
+        @processing = @threads.any? { |name, thread| thread[:processing] }
+        @running = living
+        sleep 1
+      end
+
+      puts "All connection threads have died..."
+      rescue Interrupt=>e
+        RosettaQueue.logger.warn("Interrupt received.  Shutting down...")
+        puts "\nInterrupt received\n"
+      rescue Exception=>e
+        RosettaQueue.logger.error("Exception thrown -- #{e.class.name}: #{e.message}")
+      ensure
+        RosettaQueue.logger.warn("Cleaning up threads...")
+        stop_threads
+    end
+
+    def start_threads
+      @consumers.each do |key, consumer|
+        @threads[key] = Thread.new(key, consumer) do |a_key, a_consumer|
+          while @running
+            begin
+              RosettaQueue.logger.info("Threading consumer #{a_consumer}...")
+              Mutex.new.synchronize { a_consumer.receive }
+            rescue StopProcessingException=>e
+              RosettaQueue.logger.error("#{a_key}: Processing Stopped - receive interrupted")
+            rescue Exception=>e
+              RosettaQueue.logger.error("#{a_key}: Exception from connection.receive: #{$!}\n" + e.backtrace.join("\n\t"))
+            end
+            Thread.pass
+          end
+        end
+      end
+    end
+
+    def stop_threads
+      RosettaQueue.logger.debug("Attempting to stop all threads...")
+      @running = false
+      @threads.select { |key, thread| thread.alive? }.each do |key, thread|
+        if thread[:processing]
+          RosettaQueue.logger.debug("#{key} Skipping thread #{thread} because the consumer is processing")
+          @running = true
+          next
+        end
+        RosettaQueue.logger.debug("#{key} Stopping thread #{thread} and disconnecting the consumer")
+        thread.kill
+        @consumers[key].disconnect
+      end
+    end
+  end
+end