eventq_rabbitmq 1.17.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2ac92d8a90294367f4ee7b8f69034b90f6605d8481d755c8a50712a272acb103
+  data.tar.gz: 4fc200d78f706bf3fd57040a4b310b6b7a591ba3337a2114582d2aea814c4a8d
+SHA512:
+  metadata.gz: cdc0d278a62aea36ece0309710cc34ee46b7d3229f0d819b15bec7e23b65e128d60ff14d90c11e969b2a5d437771dd3a8608b8d51bd581d23a34502390642cb0
+  data.tar.gz: 2710024884afd8230a1762cde151983321b37fe67dfa4c19d450466d72fd3029f24a268ef741fa75daba3364fc8885125d41f3ec7c1d4c691db707f37d6a4892

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "eventq_rabbitmq"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/eventq_rabbitmq/default_queue.rb

@@ -0,0 +1,12 @@
+module EventQ
+  module RabbitMq
+    class DefaultQueue < Queue
+      def initialize
+        @name = 'Default'.freeze
+        @allow_retry = false
+        @max_retry_attempts = 1
+      end
+    end
+  end
+end
+

data/lib/eventq_rabbitmq/jruby/rabbitmq_queue_worker.rb

@@ -0,0 +1,373 @@
+require 'java'
+java_import java.util.concurrent.Executors
+module EventQ
+  module RabbitMq
+    class QueueWorker
+      include EventQ::WorkerId
+
+      attr_accessor :is_running
+
+      def initialize
+        @threads = []
+        @forks = []
+        @is_running = false
+
+        @retry_exceeded_block = nil
+        @on_retry_block = nil
+        @on_error_block = nil
+        @hash_helper = HashKit::Helper.new
+        @serialization_provider_manager = EventQ::SerializationProviders::Manager.new
+        @signature_provider_manager = EventQ::SignatureProviders::Manager.new
+        @last_gc_flush = Time.now
+        @gc_flush_interval = 10
+      end
+
+      def start(queue, options = {}, &block)
+
+        EventQ.logger.info("[#{self.class}] - Preparing to start listening for messages.")
+
+        configure(queue, options)
+
+        raise "[#{self.class}] - Worker is already running." if running?
+
+        if options[:client] == nil
+          raise "[#{self.class}] - :client (QueueClient) must be specified."
+        end
+
+        EventQ.logger.info("[#{self.class}] - Listening for messages.")
+        EventQ.logger.debug do
+          "[#{self.class} #start] - Listening for messages on queue: #{EventQ.create_queue_name(queue.name)}"
+        end
+
+        start_process(options, queue, block)
+
+      end
+
+      def start_process(options, queue, block)
+
+        @is_running = true
+
+        %w'INT TERM'.each do |sig|
+          Signal.trap(sig) {
+            stop
+            exit
+          }
+        end
+
+        if !options.key?(:durable)
+          options[:durable] = true
+        end
+
+        client = options[:client]
+        manager = EventQ::RabbitMq::QueueManager.new
+        manager.durable = options[:durable]
+        @connection = client.get_connection
+
+        @executor = java.util.concurrent.Executors::newFixedThreadPool @thread_count
+
+        #loop through each thread count
+        @thread_count.times do
+
+          @executor.execute do
+
+            #begin the queue loop for this thread
+            while true do
+
+              #check if the worker is still allowed to run and break out of thread loop if not
+              unless running?
+                break
+              end
+
+              if @executor.is_shutdown
+                break
+              end
+
+              has_received_message = false
+
+              begin
+
+                channel = @connection.create_channel
+
+                has_received_message = thread_process_iteration(channel, manager, queue, block)
+
+              rescue => e
+                EventQ.logger.error("An unhandled error occurred. Error: #{e} | Backtrace: #{e.backtrace}")
+                call_on_error_block(error: e)
+              end
+
+              if channel != nil && channel.open?
+                channel.close
+              end
+
+              gc_flush
+
+              if !has_received_message
+                EventQ.logger.debug { "[#{self.class}] - No message received." }
+                if @sleep > 0
+                  EventQ.logger.debug { "[#{self.class}] - Sleeping for #{@sleep} seconds" }
+                  sleep(@sleep)
+                end
+              end
+
+            end
+
+          end
+
+        end
+
+        if options.key?(:wait) && options[:wait] == true
+          while running? do end
+          @connection.close if @connection.open?
+        end
+
+        return true
+
+      end
+
+      def call_on_error_block(error:, message: nil)
+        if @on_error_block
+          EventQ.logger.debug { "[#{self.class}] - Executing on_error block." }
+          begin
+            @on_error_block.call(error, message)
+          rescue => e
+            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_error block. Error: #{e}")
+          end
+        else
+          EventQ.logger.debug { "[#{self.class}] - No on_error block specified to execute." }
+        end
+      end
+
+      def gc_flush
+        if Time.now - last_gc_flush > @gc_flush_interval
+          GC.start
+          @last_gc_flush = Time.now
+        end
+      end
+
+      def last_gc_flush
+        @last_gc_flush
+      end
+
+      def thread_process_iteration(channel, manager, queue, block)
+
+        #get the queue
+        q = manager.get_queue(channel, queue)
+        retry_exchange = manager.get_retry_exchange(channel, queue)
+
+        received = false
+
+        begin
+          delivery_info, payload = manager.pop_message(queue: q)
+
+          #check that message was received
+          if payload != nil
+            received = true
+            begin
+              tag_processing_thread
+              process_message(payload, queue, channel, retry_exchange, delivery_info, block)
+            ensure
+              untag_processing_thread
+            end
+
+          end
+
+        rescue => e
+          EventQ.logger.error("[#{self.class}] - An error occurred attempting to process a message. Error: #{e} | Backtrace: #{e.backtrace}")
+          call_on_error_block(error: e)
+        end
+
+        return received
+      end
+
+      def stop
+        EventQ.logger.info { "[#{self.class}] - Stopping..." }
+        @is_running = false
+        @executor.shutdown
+        if @connection != nil
+          @connection.close if @connection.open?
+        end
+        return true
+      end
+
+      def on_retry_exceeded(&block)
+        @retry_exceeded_block = block
+        return nil
+      end
+
+      def on_retry(&block)
+        @on_retry_block = block
+        return nil
+      end
+
+      def on_error(&block)
+        @on_error_block = block
+        return nil
+      end
+
+      def running?
+        return @is_running
+      end
+
+      def deserialize_message(payload)
+        provider = @serialization_provider_manager.get_provider(EventQ::Configuration.serialization_provider)
+        return provider.deserialize(payload)
+      end
+
+      def serialize_message(msg)
+        provider = @serialization_provider_manager.get_provider(EventQ::Configuration.serialization_provider)
+        return provider.serialize(msg)
+      end
+
+      def call_on_retry_exceeded_block(message)
+        if @retry_exceeded_block != nil
+          EventQ.logger.debug { "[#{self.class}] - Executing on_retry_exceeded block." }
+          begin
+            @retry_exceeded_block.call(message)
+          rescue => e
+            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_retry_exceeded block. Error: #{e}")
+          end
+        else
+          EventQ.logger.debug { "[#{self.class}] - No on_retry_exceeded block specified." }
+        end
+      end
+
+      def call_on_retry_block(message)
+        if @on_retry_block
+          EventQ.logger.debug { "[#{self.class}] - Executing on_retry block." }
+          begin
+            @on_retry_block.call(message, abort)
+          rescue => e
+            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_retry block. Error: #{e}")
+          end
+        else
+          EventQ.logger.debug { "[#{self.class}] - No on_retry block specified." }
+        end
+      end
+
+      def reject_message(channel, message, delivery_tag, retry_exchange, queue, abort)
+
+        EventQ.logger.info("[#{self.class}] - Message rejected removing from queue.")
+        #reject the message to remove from queue
+        channel.reject(delivery_tag, false)
+
+        #check if the message retry limit has been exceeded
+        if message.retry_attempts >= queue.max_retry_attempts
+
+          EventQ.logger.info("[#{self.class}] - Message retry attempt limit exceeded. Msg: #{serialize_message(message)}")
+
+          call_on_retry_exceeded_block(message)
+
+        #check if the message is allowed to be retried
+        elsif queue.allow_retry
+
+          EventQ.logger.debug { "[#{self.class}] - Incrementing retry attempts count." }
+          message.retry_attempts += 1
+
+          if queue.allow_retry_back_off == true
+            EventQ.logger.debug { "[#{self.class}] - Calculating message back off retry delay. Attempts: #{message.retry_attempts} * Retry Delay: #{queue.retry_delay}" }
+            message_ttl = message.retry_attempts * queue.retry_delay
+            if (message.retry_attempts * queue.retry_delay) > queue.max_retry_delay
+              EventQ.logger.debug { "[#{self.class}] - Max message back off retry delay reached." }
+              message_ttl = queue.max_retry_delay
+            end
+          else
+            EventQ.logger.debug { "[#{self.class}] - Setting fixed retry delay for message." }
+            message_ttl = queue.retry_delay
+          end
+
+          EventQ.logger.debug { "[#{self.class}] - Sending message for retry. Message TTL: #{message_ttl}" }
+          retry_exchange.publish(serialize_message(message), :expiration => message_ttl)
+          EventQ.logger.debug { "[#{self.class}] - Published message to retry exchange." }
+
+          call_on_retry_block(message)
+
+        end
+
+        return true
+
+      end
+
+      def configure(queue, options = {})
+
+        @queue = queue
+
+        #default thread count
+        @thread_count = 4
+        if options.key?(:thread_count)
+          @thread_count = options[:thread_count]
+        end
+
+        #default sleep time in seconds
+        @sleep = 15
+        if options.key?(:sleep)
+          @sleep = options[:sleep]
+        end
+
+        @fork_count = 1
+        if options.key?(:fork_count)
+          @fork_count = options[:fork_count]
+        end
+
+        @gc_flush_interval = 10
+        if options.key?(:gc_flush_interval)
+          @gc_flush_interval = options[:gc_flush_interval]
+        end
+
+        EventQ.logger.info("[#{self.class}] - Configuring. Process Count: #{@fork_count} | Thread Count: #{@thread_count} | Interval Sleep: #{@sleep}.")
+
+        return true
+
+      end
+
+      private
+
+      def process_message(payload, queue, channel, retry_exchange, delivery_tag, block)
+        abort = false
+        error = false
+        message = deserialize_message(payload)
+
+        EventQ.logger.info("[#{self.class}] - Message received. Retry Attempts: #{message.retry_attempts}")
+
+        @signature_provider_manager.validate_signature(message: message, queue: queue)
+
+        message_args = EventQ::MessageArgs.new(type: message.type,
+                                               retry_attempts: message.retry_attempts,
+                                               context: message.context,
+                                               content_type: message.content_type)
+
+        if(!EventQ::NonceManager.is_allowed?(message.id))
+          EventQ.logger.info("[#{self.class}] - Duplicate Message received. Dropping message.")
+          channel.acknowledge(delivery_tag, false)
+          return false
+        end
+
+        #begin worker block for queue message
+        begin
+          block.call(message.content, message_args)
+
+          if message_args.abort == true
+            abort = true
+            EventQ.logger.info("[#{self.class}] - Message aborted.")
+          else
+            #accept the message as processed
+            channel.acknowledge(delivery_tag, false)
+            EventQ.logger.info("[#{self.class}] - Message acknowledged.")
+          end
+
+        rescue => e
+          EventQ.logger.error("[#{self.class}] - An unhandled error happened attempting to process a queue message. Error: #{e} | Backtrace: #{e.backtrace}")
+          error = true
+          call_on_error_block(error: e, message: message)
+        end
+
+        if error || abort
+          EventQ::NonceManager.failed(message.id)
+          reject_message(channel, message, delivery_tag, retry_exchange, queue, abort)
+        else
+          EventQ::NonceManager.complete(message.id)
+        end
+      end
+    end
+  end
+end
+

data/lib/eventq_rabbitmq/rabbitmq_eventq_client.rb

@@ -0,0 +1,127 @@
+module EventQ
+  module RabbitMq
+    # Implements a general interface to raise an event
+    # EventQ::Amazon::EventQClient is the sister-class which does the same for AWS
+    class EventQClient
+
+      def initialize(options={})
+
+        if options[:client] == nil
+          raise ':client (QueueClient) must be specified.'.freeze
+        end
+
+        @client = options[:client]
+        @queue_manager = QueueManager.new
+        @event_raised_exchange = EventRaisedExchange.new
+        @serialization_manager = EventQ::SerializationProviders::Manager.new
+        @signature_manager = EventQ::SignatureProviders::Manager.new
+
+        #this array is used to record known event types
+        @known_event_types = []
+      end
+
+      def registered?(event_type)
+        @known_event_types.include?(event_type)
+      end
+
+      def register_event(event_type)
+        if registered?(event_type)
+          return true
+        end
+
+        @known_event_types << event_type
+        true
+      end
+
+      def publish(topic:, event:, context: {})
+        raise_event(topic, event, context)
+      end
+
+      def raise_event(event_type, event, context = {})
+        register_event(event_type)
+
+        _event_type = EventQ.create_event_type(event_type)
+
+        with_connection do |channel|
+          exchange = @queue_manager.get_exchange(channel, @event_raised_exchange)
+
+          message = serialized_message(_event_type, event, context)
+
+          exchange.publish(message, routing_key: _event_type)
+
+          EventQ.logger.debug do
+            "[#{self.class}] - Raised event to Exchange: #{_event_type} | Message: #{message}."
+          end
+        end
+      end
+
+      def raise_event_in_queue(event_type, event, queue, delay, context = {})
+        register_event(event_type)
+
+        _event_type = EventQ.create_event_type(event_type)
+
+        with_connection do |channel|
+          exchange = @queue_manager.get_queue_exchange(channel, queue)
+
+          delay_exchange = @queue_manager.get_delay_exchange(channel, queue, delay)
+
+          delay_queue = @queue_manager.create_delay_queue(channel, queue, exchange.name, delay)
+          delay_queue.bind(delay_exchange, routing_key: _event_type)
+
+          _queue_name = EventQ.create_queue_name(queue.name)
+
+          q = channel.queue(_queue_name, durable: @queue_manager.durable)
+          q.bind(exchange, routing_key: _event_type)
+
+          message = serialized_message(_event_type, event, context)
+
+          delay_exchange.publish(message, routing_key: _event_type)
+
+          EventQ.logger.debug do
+            "[#{self.class}] - Raised event to Exchange: #{_event_type} | Message: #{message} | Delay: #{delay}."
+          end
+        end
+      end
+
+      def new_message
+        EventQ::QueueMessage.new
+      end
+
+      private
+
+      def with_connection
+        connection = @client.get_connection
+
+        begin
+          channel = connection.create_channel
+
+          yield(channel)
+
+        ensure
+          channel&.close if channel.open?
+          connection.close
+        end
+
+        true
+      end
+
+      def serialized_message(event_type, event, context)
+        qm = new_message
+        qm.content = event
+        qm.type = event_type
+        qm.context = context
+        qm.content_type = event.class.to_s
+
+        if EventQ::Configuration.signature_secret != nil
+          provider = @signature_manager.get_provider(EventQ::Configuration.signature_provider)
+          qm.signature = provider.write(message: qm, secret: EventQ::Configuration.signature_secret)
+        end
+
+        serialization_provider = @serialization_manager.get_provider(EventQ::Configuration.serialization_provider)
+
+        serialization_provider.serialize(qm)
+      end
+    end
+  end
+end
+

data/lib/eventq_rabbitmq/rabbitmq_queue_client.rb

@@ -0,0 +1,54 @@
+module EventQ
+  module RabbitMq
+    class QueueClient
+
+      GUEST = 'guest'.freeze
+
+      def initialize(options = {})
+
+        if options[:endpoint] == nil
+          raise ':endpoint must be specified.'.freeze
+        end
+
+        @endpoint = options[:endpoint]
+
+        @port = Integer(options[:port] || 5672)
+
+        @user = options[:user] || GUEST
+
+        @password = options[:password] || GUEST
+
+        @ssl = options[:ssl] == true || false
+
+      end
+
+      def connection_options
+        {
+            :host => @endpoint,
+            :port => @port,
+            :user => @user,
+            :pass => @password,
+            :ssl => @ssl,
+            :read_timeout => 4,
+            :heartbeat => 8,
+            :continuation_timeout => 5000,
+            :automatically_recover => true,
+            :network_recovery_interval => 1,
+            :recover_from_connection_close => true
+        }
+      end
+
+      def get_connection
+        if RUBY_PLATFORM =~ /java/
+          conn = MarchHare.connect(connection_options)
+        else
+          conn = Bunny.new(connection_options)
+        end
+
+        conn.start
+        return conn
+      end
+
+    end
+  end
+end

data/lib/eventq_rabbitmq/rabbitmq_queue_manager.rb

@@ -0,0 +1,104 @@
+module EventQ
+  module RabbitMq
+    class QueueManager
+
+      X_DEAD_LETTER_EXCHANGE = 'x-dead-letter-exchange'.freeze
+      X_MESSAGE_TTL = 'x-message-ttl'.freeze
+
+      attr_accessor :durable
+
+      def initialize
+        @event_raised_exchange = EventQ::EventRaisedExchange.new
+        @durable = true
+      end
+
+      def get_queue(channel, queue)
+
+        _queue_name = EventQ.create_queue_name(queue.name)
+
+        #get/create the queue
+        q = channel.queue(_queue_name, :durable => @durable)
+
+        if queue.allow_retry
+          retry_exchange = get_retry_exchange(channel, queue)
+          subscriber_exchange = get_subscriber_exchange(channel, queue)
+
+          retry_queue = get_retry_queue(channel, queue)
+          retry_queue.bind(retry_exchange)
+
+          q.bind(subscriber_exchange)
+        end
+
+        return q
+      end
+
+      def pop_message(queue:)
+        if RUBY_PLATFORM =~ /java/
+          headers, payload = queue.pop({ :ack => true, :block => true })
+          if headers == nil
+            return [nil,nil]
+          end
+          [headers.delivery_tag, payload]
+        else
+          headers, properties, payload = queue.pop({ :manual_ack => true, :block => true })
+          if headers == nil
+            return [nil,nil]
+          end
+          [headers.delivery_tag, payload]
+        end
+      end
+
+      def get_queue_exchange(channel, queue)
+        _exchange_name = EventQ.create_exchange_name(queue.name)
+        channel.direct("#{_exchange_name}.ex")
+      end
+
+      def get_retry_exchange(channel, queue)
+        _queue_name = EventQ.create_queue_name(queue.name)
+        return channel.fanout("#{_queue_name}.r.ex")
+      end
+
+      def get_subscriber_exchange(channel, queue)
+        _queue_name = EventQ.create_queue_name(queue.name)
+        return channel.fanout("#{_queue_name}.ex")
+      end
+
+      def get_delay_exchange(channel, queue, delay)
+        _queue_name = EventQ.create_queue_name(queue.name)
+        channel.direct("#{_queue_name}.#{delay}.d.ex")
+      end
+
+      def get_retry_queue(channel, queue)
+        subscriber_exchange = get_subscriber_exchange(channel, queue)
+
+        _queue_name = EventQ.create_queue_name(queue.name)
+
+        if queue.allow_retry_back_off == true
+
+          EventQ.logger.debug { "[#{self.class}] - Requesting retry queue. x-dead-letter-exchange: #{subscriber_exchange.name} | x-message-ttl: #{queue.max_retry_delay}" }
+
+          return channel.queue("#{_queue_name}.r", :durable => @durable, :arguments => { X_DEAD_LETTER_EXCHANGE => subscriber_exchange.name, X_MESSAGE_TTL => queue.max_retry_delay })
+
+        else
+
+          EventQ.logger.debug { "[#{self.class}] - Requesting retry queue. x-dead-letter-exchange: #{subscriber_exchange.name} | x-message-ttl: #{queue.retry_delay}" }
+
+          return channel.queue("#{_queue_name}.r", :durable => @durable, :arguments => { X_DEAD_LETTER_EXCHANGE => subscriber_exchange.name, X_MESSAGE_TTL => queue.retry_delay })
+
+        end
+
+      end
+
+      def create_delay_queue(channel, queue, dlx_name, delay=0)
+        queue_name = EventQ.create_queue_name(queue.name)
+        channel.queue("#{queue_name}.#{delay}.delay", durable: @durable,
+                      arguments: { X_DEAD_LETTER_EXCHANGE => dlx_name, X_MESSAGE_TTL => delay * 1000 })
+      end
+
+      def get_exchange(channel, exchange)
+        _exchange_name = EventQ.create_exchange_name(exchange.name)
+        return channel.direct(_exchange_name, :durable => @durable)
+      end
+    end
+  end
+end

data/lib/eventq_rabbitmq/rabbitmq_queue_worker.rb

@@ -0,0 +1,389 @@
+module EventQ
+  module RabbitMq
+    class QueueWorker
+      include EventQ::WorkerId
+
+      attr_accessor :is_running
+
+      def initialize
+        @threads = []
+        @forks = []
+        @is_running = false
+
+        @retry_exceeded_block = nil
+        @on_retry_block = nil
+        @on_error_block = nil
+        @hash_helper = HashKit::Helper.new
+        @serialization_provider_manager = EventQ::SerializationProviders::Manager.new
+        @signature_provider_manager = EventQ::SignatureProviders::Manager.new
+        @last_gc_flush = Time.now
+        @gc_flush_interval = 10
+      end
+
+      def start(queue, options = {}, &block)
+
+        EventQ.logger.info("[#{self.class}] - Preparing to start listening for messages.")
+
+        configure(queue, options)
+
+        raise "[#{self.class}] - Worker is already running." if running?
+
+        if options[:client] == nil
+          raise "[#{self.class}] - :client (QueueClient) must be specified."
+        end
+
+        EventQ.logger.info("[#{self.class}] - Listening for messages.")
+        EventQ.logger.debug do
+          "[#{self.class} #start] - Listening for messages on queue: #{EventQ.create_queue_name(queue.name)}"
+        end
+
+        @forks = []
+
+        if @fork_count > 1
+          @fork_count.times do
+            pid = fork do
+              start_process(options, queue, block)
+            end
+            @forks.push(pid)
+          end
+
+          if options.key?(:wait) && options[:wait] == true
+            @forks.each { |pid| Process.wait(pid) }
+          end
+
+        else
+          start_process(options, queue, block)
+        end
+
+      end
+
+      def start_process(options, queue, block)
+
+        @is_running = true
+
+        %w'INT TERM'.each do |sig|
+          Signal.trap(sig) {
+            stop
+            exit
+          }
+        end
+
+        if !options.key?(:durable)
+          options[:durable] = true
+        end
+
+        client = options[:client]
+        manager = EventQ::RabbitMq::QueueManager.new
+        manager.durable = options[:durable]
+        @connection = client.get_connection
+
+        @threads = []
+
+        #loop through each thread count
+        @thread_count.times do
+          thr = Thread.new do
+
+            #begin the queue loop for this thread
+            while true do
+
+              #check if the worker is still allowed to run and break out of thread loop if not
+              unless running?
+                break
+              end
+
+              has_received_message = false
+
+              begin
+
+                channel = @connection.create_channel
+
+                has_received_message = thread_process_iteration(channel, manager, queue, block)
+
+              rescue => e
+                EventQ.logger.error("An unhandled error occurred. Error: #{e} | Backtrace: #{e.backtrace}")
+                call_on_error_block(error: e)
+              end
+
+              if channel != nil && channel.open?
+                channel.close
+              end
+
+              gc_flush
+
+              if !has_received_message
+                EventQ.logger.debug { "[#{self.class}] - No message received." }
+                if @sleep > 0
+                  EventQ.logger.debug { "[#{self.class}] - Sleeping for #{@sleep} seconds" }
+                  sleep(@sleep)
+                end
+              end
+
+            end
+
+          end
+          @threads.push(thr)
+
+        end
+
+        if options.key?(:wait) && options[:wait] == true
+          @threads.each { |thr| thr.join }
+          @connection.close if @connection.open?
+        end
+
+        return true
+
+      end
+
+      def call_on_error_block(error:, message: nil)
+        if @on_error_block
+          EventQ.logger.debug { "[#{self.class}] - Executing on_error block." }
+          begin
+            @on_error_block.call(error, message)
+          rescue => e
+            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_error block. Error: #{e}")
+          end
+        else
+          EventQ.logger.debug { "[#{self.class}] - No on_error block specified to execute." }
+        end
+      end
+
+      def gc_flush
+        if Time.now - last_gc_flush > @gc_flush_interval
+          GC.start
+          @last_gc_flush = Time.now
+        end
+      end
+
+      def last_gc_flush
+        @last_gc_flush
+      end
+
+      def thread_process_iteration(channel, manager, queue, block)
+
+        #get the queue
+        q = manager.get_queue(channel, queue)
+        retry_exchange = manager.get_retry_exchange(channel, queue)
+
+        received = false
+
+        begin
+          delivery_info, payload = manager.pop_message(queue: q)
+
+          #check that message was received
+          if payload != nil
+            received = true
+            begin
+              tag_processing_thread
+              process_message(payload, queue, channel, retry_exchange, delivery_info, block)
+            ensure
+              untag_processing_thread
+            end
+
+          end
+
+        rescue => e
+          EventQ.logger.error("[#{self.class}] - An error occurred attempting to process a message. Error: #{e} | Backtrace: #{e.backtrace}")
+          call_on_error_block(error: e)
+        end
+
+        return received
+      end
+
+      def stop
+        EventQ.logger.info { "[#{self.class}] - Stopping..." }
+        @is_running = false
+        Thread.list.each do |thread|
+          thread.exit unless thread == Thread.current
+        end
+        if @connection != nil
+          begin
+            @connection.close if @connection.open?
+          rescue Timeout::Error
+            EventQ.logger.error { 'Timeout occurred closing connection.' }
+          end
+        end
+        return true
+      end
+
+      def on_retry_exceeded(&block)
+        @retry_exceeded_block = block
+        return nil
+      end
+
+      def on_retry(&block)
+        @on_retry_block = block
+        return nil
+      end
+
+      def on_error(&block)
+        @on_error_block = block
+        return nil
+      end
+
+      def running?
+        return @is_running
+      end
+
+      def deserialize_message(payload)
+        provider = @serialization_provider_manager.get_provider(EventQ::Configuration.serialization_provider)
+        return provider.deserialize(payload)
+      end
+
+      def serialize_message(msg)
+        provider = @serialization_provider_manager.get_provider(EventQ::Configuration.serialization_provider)
+        return provider.serialize(msg)
+      end
+
+      def call_on_retry_exceeded_block(message)
+        if @retry_exceeded_block != nil
+          EventQ.logger.debug { "[#{self.class}] - Executing on_retry_exceeded block." }
+          begin
+            @retry_exceeded_block.call(message)
+          rescue => e
+            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_retry_exceeded block. Error: #{e}")
+          end
+        else
+          EventQ.logger.debug { "[#{self.class}] - No on_retry_exceeded block specified." }
+        end
+      end
+
+      def call_on_retry_block(message)
+        if @on_retry_block
+          EventQ.logger.debug { "[#{self.class}] - Executing on_retry block." }
+          begin
+            @on_retry_block.call(message, abort)
+          rescue => e
+            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_retry block. Error: #{e}")
+          end
+        else
+          EventQ.logger.debug { "[#{self.class}] - No on_retry block specified." }
+        end
+      end
+
+      def reject_message(channel, message, delivery_tag, retry_exchange, queue, abort)
+
+        EventQ.logger.info("[#{self.class}] - Message rejected removing from queue.")
+        #reject the message to remove from queue
+        channel.reject(delivery_tag, false)
+
+        #check if the message retry limit has been exceeded
+        if message.retry_attempts >= queue.max_retry_attempts
+
+          EventQ.logger.info("[#{self.class}] - Message retry attempt limit exceeded. Msg: #{serialize_message(message)}")
+
+          call_on_retry_exceeded_block(message)
+
+        #check if the message is allowed to be retried
+        elsif queue.allow_retry
+
+          EventQ.logger.debug { "[#{self.class}] - Incrementing retry attempts count." }
+          message.retry_attempts += 1
+
+          if queue.allow_retry_back_off == true
+            EventQ.logger.debug { "[#{self.class}] - Calculating message back off retry delay. Attempts: #{message.retry_attempts} * Retry Delay: #{queue.retry_delay}" }
+            message_ttl = message.retry_attempts * queue.retry_delay
+            if (message.retry_attempts * queue.retry_delay) > queue.max_retry_delay
+              EventQ.logger.debug { "[#{self.class}] - Max message back off retry delay reached." }
+              message_ttl = queue.max_retry_delay
+            end
+          else
+            EventQ.logger.debug { "[#{self.class}] - Setting fixed retry delay for message." }
+            message_ttl = queue.retry_delay
+          end
+
+          EventQ.logger.debug { "[#{self.class}] - Sending message for retry. Message TTL: #{message_ttl}" }
+          retry_exchange.publish(serialize_message(message), :expiration => message_ttl)
+          EventQ.logger.debug { "[#{self.class}] - Published message to retry exchange." }
+
+          call_on_retry_block(message)
+
+        end
+
+        return true
+
+      end
+
+      def configure(queue, options = {})
+
+        @queue = queue
+
+        #default thread count
+        @thread_count = 4
+        if options.key?(:thread_count)
+          @thread_count = options[:thread_count]
+        end
+
+        #default sleep time in seconds
+        @sleep = 15
+        if options.key?(:sleep)
+          @sleep = options[:sleep]
+        end
+
+        @fork_count = 1
+        if options.key?(:fork_count)
+          @fork_count = options[:fork_count]
+        end
+
+        @gc_flush_interval = 10
+        if options.key?(:gc_flush_interval)
+          @gc_flush_interval = options[:gc_flush_interval]
+        end
+
+        EventQ.logger.info("[#{self.class}] - Configuring. Process Count: #{@fork_count} | Thread Count: #{@thread_count} | Interval Sleep: #{@sleep}.")
+
+        return true
+
+      end
+
+      private
+
+      def process_message(payload, queue, channel, retry_exchange, delivery_tag, block)
+        abort = false
+        error = false
+        message = deserialize_message(payload)
+
+        EventQ.logger.info("[#{self.class}] - Message received. Retry Attempts: #{message.retry_attempts}")
+
+        @signature_provider_manager.validate_signature(message: message, queue: queue)
+
+        message_args = EventQ::MessageArgs.new(type: message.type,
+                                               retry_attempts: message.retry_attempts,
+                                               context: message.context,
+                                               content_type: message.content_type)
+
+        if(!EventQ::NonceManager.is_allowed?(message.id))
+          EventQ.logger.info("[#{self.class}] - Duplicate Message received. Dropping message.")
+          channel.acknowledge(delivery_tag, false)
+          return false
+        end
+
+        #begin worker block for queue message
+        begin
+          block.call(message.content, message_args)
+
+          if message_args.abort == true
+            abort = true
+            EventQ.logger.info("[#{self.class}] - Message aborted.")
+          else
+            #accept the message as processed
+            channel.acknowledge(delivery_tag, false)
+            EventQ.logger.info("[#{self.class}] - Message acknowledged.")
+          end
+
+        rescue => e
+          EventQ.logger.error("[#{self.class}] - An unhandled error happened attempting to process a queue message. Error: #{e} | Backtrace: #{e.backtrace}")
+          error = true
+          call_on_error_block(error: e, message: message)
+        end
+
+        if error || abort
+          EventQ::NonceManager.failed(message.id)
+          reject_message(channel, message, delivery_tag, retry_exchange, queue, abort)
+        else
+          EventQ::NonceManager.complete(message.id)
+        end
+      end
+    end
+  end
+end
+

data/lib/eventq_rabbitmq/rabbitmq_status_checker.rb

@@ -0,0 +1,62 @@
+module EventQ
+  module RabbitMq
+    class StatusChecker
+
+      def initialize(client:, queue_manager:)
+
+        if client == nil
+          raise 'client  must be specified.'.freeze
+        end
+
+        @client = client
+
+        if queue_manager == nil
+          raise 'queue_manager  must be specified.'.freeze
+        end
+
+        @queue_manager = queue_manager
+
+        @event_raised_exchange = EventRaisedExchange.new
+
+      end
+
+      def queue?(queue)
+
+        outcome = true
+
+        begin
+          connection = @client.get_connection
+          channel = connection.create_channel
+          _queue_name = EventQ.create_queue_name(queue.name)
+          channel.queue(_queue_name, :durable => true)
+        rescue
+          outcome = false
+        ensure
+          channel.close if channel
+          connection.close if connection
+        end
+
+        outcome
+      end
+
+      def event_type?(event_type)
+
+        outcome = true
+
+        begin
+          connection = @client.get_connection
+          channel = connection.create_channel
+          @queue_manager.get_exchange(channel, @event_raised_exchange)
+        rescue
+          outcome = false
+        ensure
+          channel.close if channel
+          connection.close if connection
+        end
+
+        outcome
+      end
+
+    end
+  end
+end

data/lib/eventq_rabbitmq/rabbitmq_subscription_manager.rb

@@ -0,0 +1,54 @@
+module EventQ
+  module RabbitMq
+    class SubscriptionManager
+
+      def initialize(options = {})
+        if options[:client] == nil
+          raise ':client (QueueClient) must be specified.'.freeze
+        end
+        @client = options[:client]
+        @queue_manager = QueueManager.new
+        @event_raised_exchange = EventQ::EventRaisedExchange.new
+      end
+
+      def subscribe(event_type, queue)
+
+        _event_type = EventQ.create_event_type(event_type)
+
+        connection = @client.get_connection
+        channel = connection.create_channel
+
+        queue = @queue_manager.get_queue(channel, queue)
+        exchange = @queue_manager.get_exchange(channel, @event_raised_exchange)
+
+        queue.bind(exchange, :routing_key => _event_type)
+
+        channel.close
+        connection.close
+
+        EventQ.logger.debug do
+          "[#{self.class} #subscribe] - Subscribing queue: #{EventQ.create_queue_name(queue.name)} to Exchange: #{_event_type}"
+        end
+
+        return true
+      end
+
+      def unsubscribe(queue)
+
+        connection = @client.get_connection
+        channel = connection.create_channel
+
+        queue = @queue_manager.get_queue(channel, queue)
+        exchange = @queue_manager.get_exchange(channel, @event_raised_exchange)
+
+        queue.unbind(exchange)
+
+        channel.close
+        connection.close
+
+        return true
+      end
+
+    end
+  end
+end

data/lib/eventq_rabbitmq/version.rb

@@ -0,0 +1,3 @@
+module EventqRabbitmq
+  VERSION = "1.17.0"
+end

data/lib/eventq_rabbitmq.rb

@@ -0,0 +1,49 @@
+require 'eventq_base'
+if RUBY_PLATFORM =~ /java/
+  require 'march_hare'
+else
+  require 'bunny'
+end
+
+require 'hash_kit'
+require_relative '../lib/eventq_rabbitmq/version'
+require_relative '../lib/eventq_rabbitmq/rabbitmq_queue_client'
+require_relative '../lib/eventq_rabbitmq/rabbitmq_queue_manager'
+
+if RUBY_PLATFORM =~ /java/
+  require_relative '../lib/eventq_rabbitmq/jruby/rabbitmq_queue_worker'
+else
+  require_relative '../lib/eventq_rabbitmq/rabbitmq_queue_worker'
+end
+
+require_relative '../lib/eventq_rabbitmq/rabbitmq_subscription_manager'
+require_relative '../lib/eventq_rabbitmq/rabbitmq_eventq_client'
+require_relative '../lib/eventq_rabbitmq/default_queue'
+require_relative '../lib/eventq_rabbitmq/rabbitmq_status_checker'
+
+module EventQ
+  def self.namespace
+    @namespace
+  end
+  def self.namespace=(value)
+    @namespace = value
+  end
+  def self.create_event_type(event_type)
+    if EventQ.namespace == nil
+      return event_type
+    end
+    return "#{EventQ.namespace}-#{event_type}"
+  end
+  def self.create_queue_name(queue_name)
+    if EventQ.namespace == nil
+      return queue_name
+    end
+    return "#{EventQ.namespace}-#{queue_name}"
+  end
+  def self.create_exchange_name(exchange_name)
+    if EventQ.namespace == nil
+      return exchange_name
+    end
+    return "#{EventQ.namespace}-#{exchange_name}"
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: eventq_rabbitmq
+version: !ruby/object:Gem::Version
+  version: 1.17.0
+platform: java
+authors:
+- vaughanbrittonsage
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2017-06-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  name: eventq_base
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: march_hare
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This is the rabbitmq implementation for EventQ
+email:
+- vaughanbritton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/setup
+- lib/eventq_rabbitmq.rb
+- lib/eventq_rabbitmq/default_queue.rb
+- lib/eventq_rabbitmq/jruby/rabbitmq_queue_worker.rb
+- lib/eventq_rabbitmq/rabbitmq_eventq_client.rb
+- lib/eventq_rabbitmq/rabbitmq_queue_client.rb
+- lib/eventq_rabbitmq/rabbitmq_queue_manager.rb
+- lib/eventq_rabbitmq/rabbitmq_queue_worker.rb
+- lib/eventq_rabbitmq/rabbitmq_status_checker.rb
+- lib/eventq_rabbitmq/rabbitmq_subscription_manager.rb
+- lib/eventq_rabbitmq/version.rb
+homepage: https://github.com/vaughanbrittonsage/eventq
+licenses:
+- MIT
+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.6.11
+signing_key:
+specification_version: 4
+summary: This is the rabbitmq implementation for EventQ
+test_files: []