eventq 2.0.0.rc1 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29d2e0dbde90c017daf4729cf39dd998c499b09f5a54d329d0546048f812b729
-  data.tar.gz: 08ab2c25998abdaf811169d26b1140107c671d1040091cc2294d0b5c6df87baf
+  metadata.gz: f9337dac62d76513c21ca56ebfb129212d227a8979ef57e8bade4e3cafe445bf
+  data.tar.gz: 7b5e777c81e23f97500741a6a1ca27ee5e2e6a2d8d3134d4cf3544da5985c801
 SHA512:
-  metadata.gz: 82af850fe3d231f5966150a655286e057fcb71bea23900e6924381d186dcadf594011c9054eb7a9c87e35fb0cb768dca8dc166de81bd54801f94016d431e9bdd
-  data.tar.gz: 13d4ee3700ee280297cd731c25c9448c00171384c53b21bc35d69cc6c23c9c3b275a0c79d327620d58ce7051134a42237125c0a02f0bd4238fa73d5d4c9f02b0
+  metadata.gz: 3eaa44ba2b8d2705ccd8bf358a115b50f3807d697f0d0455625b1107da5ff63e6a08e164bb20079936ba31a38072e047a72591f5a7d8e3446a009ec8d19d01f8
+  data.tar.gz: 7b98818050e8eb53eceb1f55d79e8a06ce08af15439e4d3fdbe66aab2de402525ddcf3990ba7687d76b410151b06a102f4a4edc8192491acd65810216843d32d

data/README.md

@@ -4,18 +4,16 @@
 [![Maintainability](https://api.codeclimate.com/v1/badges/87205b497059e2733bdc/maintainability)](https://codeclimate.com/github/Sage/eventq/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/87205b497059e2733bdc/test_coverage)](https://codeclimate.com/github/Sage/eventq/test_coverage)
 
-Welcome to EventQ. 
+Welcome to EventQ.
 
 EventQ is an event service bus framework for decoupling services and application processes.
 
 Events are raised through the EventQ client and subscribers of the event types will be broadcast the event via a persistent queue for guaranteed delivery.
+Existing solutions like ActiveJob work by assuming it posts directly to the queue provider.  EventQ takes advantage of systems that fanout notifications.
+This allows a notification to have multiple subscribers of which one is a message that EventQ can directly process.
 
 EventQ has a base layer which allows different queue implementations to be created abstracting the specific queue implementation details away from your application code.
-EventQ comes with two default adapter that support RabbitMq and AWS SNS/SQS
-
-[AWS README](./lib/eventq/eventq_aws/README.md)
-
-[RabbitMq README](./lib/eventq/eventq_rabbitmq/README.md)
+EventQ comes with two default adapters, one for AWS SNS/SQS and another for RabbitMq (Fanout/Queue).
 
 ## Installation
 
@@ -56,14 +54,15 @@ A subscription queue should be defined to receive any events raised for the subs
 **Attributes**
 
  - **allow_retry** [Bool] [Optional] [Default=false] This determines if the queue should allow processing failures to be retried.
- - **allow_retry_backoff** [Bool] [Optional] [Default=false] This is used to specify if failed messages that retry should incrementally backoff. 
+ - **allow_retry_backoff** [Bool] [Optional] [Default=false] This is used to specify if failed messages that retry should incrementally backoff.
+ - **retry_back_off_grace** [Int] [Optional] [Default=0] This is the number of times to allow retries without applying retry back off if enabled.
  - **dlq** [EventQ::Queue] [Optional] [Default=nil] A queue that will receive the messages which were not successfully processed after maximum number of receives by consumers. This is created at the same time as the parent queue.
  - **max_retry_attempts** [Int] [Optional] [Default=5] This is used to specify the max number of times an event should be allowed to retry before failing.
  - **max_receive_count** [Int] [Optional] [Default=30] The maximum number of times that a message can be received by consumers. When this value is exceeded for a message the message will be automatically sent to the Dead Letter Queue.
  - **max_retry_delay** [Int] [Optional] This is used to specify the max retry delay that should apply when allowing incremental back off.
  - **name** [String] [Required] This is the name of the queue, it must be unique.
  - **require_signature** [Bool] [Optional] [Default=false] This is used to specify if messages within this queue must be signed.
- - **retry_delay** [Int] [Optional] [Default=30000] This is used to specify the time delay in milliseconds before a failed message is re-added to the subscription queue. 
+ - **retry_delay** [Int] [Optional] [Default=30000] This is used to specify the time delay in milliseconds before a failed message is re-added to the subscription queue.
 
 **Example**
 
@@ -96,7 +95,7 @@ This method is called to subscribe a queue to an event type.
 
 	#create an instant of the queue definition
 	queue = DateChangeAddressQueue.new
-	
+
     #subscribe the queue definition to an event type
     subscription_manager.subscribe('Data:Change:Address', queue)
 
@@ -112,7 +111,7 @@ This method is called to unsubscribe a queue.
 
     #create an instant of the queue definition
 	queue = DateChangeAddressQueue.new
-	
+
     #subscribe the queue definition to an event type
     subscription_manager.unsubscribe(queue)
 
@@ -132,7 +131,7 @@ The on_retry_exceeded method allows you to specify a block that should execute w
 		#Do something with the failed event
 		....
 	end
-	
+
 #### #on_retry
 
 The on_retry method allows you to specify a block that should execute whenever an event fails to process and is retried. The event object passed to the block is a **[QueueMessage]** object, and the abort arg is a Boolean that specifies if the message was aborted (true or false).
@@ -147,7 +146,7 @@ The on_retry method allows you to specify a block that should execute whenever a
 		#Do something with the failed event
 		....
 	end
-	
+
 #### #on_error
 
 The on_error method allows you to specify a block that should execute whenever an unhandled error occurs with the worker. The could be communication failures with the queue etc.
@@ -178,7 +177,7 @@ The start method is used to specify a block to process received events and start
 > - **:sleep** [Number] [Optional] [Default=15] This is the number of seconds a thread should sleep before attempting to request another event from the subscription queue when no event has been received.
 >
 > - **:wait** [Bool] [Optional] This is used to specify that the start method should block the calling thread and wait until all parallel threads have finished. (This can be used to ensure that the background process running the worker does not exit).
-> 
+>
 > **Block arguments:**
 > - **content** [Object] This is the content of the received event.
 >
@@ -216,11 +215,11 @@ The **[QueueMessage]** is used internally to represent an event within the vario
  - **content** [Object] This is the event content.
  - **retry_attempts** [Int] This is the number of times this event message has been retried.
  - **created** [DateTime] this is when the event was initial raised.
- 
+
 ### Configuration
- 
+
 The `EventQ::Configuration` class allows global configuration options to be specified.
- 
+
 #### serialization_provider
 
 This is used to specify the serialization provider that should be used for event serialization & deserialization.
@@ -236,7 +235,7 @@ This is used to specify the serialization provider that should be used for event
 
     #set the serialization provider configuration to the JSON_PROVIDER
     EventQ::Configuration.serialization_provider = EventQ::SerializationProviders::JSON_PROVIDER
-    
+
 #### signature_provider
 
 This is used to specify the signature provider that should be used for message signing.
@@ -244,7 +243,7 @@ This is used to specify the signature provider that should be used for message s
 > **Options:**
 >
 > - **SHA256** [Default] This is provider uses SHA256 to create message signatures.
-    
+
 #### signature_secret
 
 This is used to specify the signature secret that should be used for message signing.
@@ -252,7 +251,7 @@ This is used to specify the signature secret that should be used for message sig
     #set the signature secret
     EventQ::Configuration.signature_secret = 'secret key'
 
-    
+
 ### NonceManager
 
 The NonceManager is used to prevent duplicate messages from being processed. Each event message that is raised is given a unique identifier, most message queue providers guarantee at least once delivery which may result in the message being delivered more than once. If your use case needs to enforce once only processing then 
@@ -271,7 +270,7 @@ This method is called to configure the NonceManager, and must be called before s
 **Example**
 
     EventQ::NonceManager.configure(server: 'redis://127.0.0.1:6379')
-    
+
 
 ### Namespace
 
@@ -292,14 +291,14 @@ This method is called to verify connection to a queue.
 **Params:**
 
  - **queue** [EventQ::Queue] [Required] This is a queue definition object.
- 
+
 **Return** [Boolean] (True or False)
 
 
 **Example**
 
     available = status_checker.queue?(queue)
-    
+
 ####event_type?
 
 This method is called to verify connection to an event_type (topic/exchange).
@@ -314,14 +313,45 @@ This method is called to verify connection to an event_type (topic/exchange).
 **Example**
 
     available = status_checker.event_type?(event_type)
-    
 
+## AWS Environment Variables
+
+- **AWS_SQS_ENDPOINT** [String] [Optional] This is used to specify the endpoint of the SQS service to use.
+- **AWS_SNS_ENDPOINT** [String] [Optional] This is used to specify the endpoint of the SNS service to use.
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in  the file, `EVENTQ_VERSION`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+
+### Preparing the Docker images
+
+Run the setup script of eventq to build the environment. This will create the `eventq` image.
+
+    $ cd script
+    $ ./setup.sh
+
+### Running the tests
+
+By default, the full test suite will run against the mock AWS services defined in the docker-compose.yml file.  It also will run the tests for RabbitMq.
+
+If you want to run the tests with AWS directly, you will need an AWS account. Put your credentials into the `.aws.env` file in the parent directory.
+You will also need to comment out the AWS_* environment variables in the `docker-compose.yml` file
+
+    $ cp ../.aws.env.template ../.aws.env
+    $ vi ../.aws.env
+
+Run the whole test suite:
+
+    $ cd script
+    $ ./test.sh
+
+You can run the specs that don't depend on an AWS account with:
+
+    $ cd script
+    $ ./test.sh --tag ~integration
 
 ## Contributing
 

data/lib/eventq/aws.rb

@@ -8,12 +8,7 @@ require_relative './eventq_aws/aws_queue_client'
 require_relative './eventq_aws/aws_queue_manager'
 require_relative './eventq_aws/aws_subscription_manager'
 require_relative './eventq_aws/aws_status_checker'
-
-if RUBY_PLATFORM =~ /java/
-  require_relative './eventq_aws/jruby/aws_queue_worker'
-else
-  require_relative './eventq_aws/aws_queue_worker'
-end
+require_relative './eventq_aws/aws_queue_worker'
 
 module EventQ
   def self.namespace

data/lib/eventq/eventq_aws/aws_queue_worker.rb

@@ -68,6 +68,11 @@ module EventQ
         EventQ.logger.info("[#{self.class}] - Configuring. Queue Poll Wait: #{options[:queue_poll_wait]}")
       end
 
+      # Logic for the RabbitMq adapter when a message is accepted
+      def acknowledge_message(poller, msg)
+        poller.delete_message(msg)
+      end
+
       private
 
       def process_message(msg, poller, queue, block)
@@ -77,51 +82,20 @@ module EventQ
         payload = JSON.load(msg.body)
         message = deserialize_message(payload[MESSAGE])
 
-        message_args = EventQ::MessageArgs.new(
-            type: message.type,
-            retry_attempts: retry_attempts,
-            context: message.context,
-            content_type: message.content_type,
-            id: message.id,
-            sent: message.created
-        )
-
-        EventQ.logger.info("[#{self.class}] - Message received. Retry Attempts: #{retry_attempts}")
-
         @signature_provider_manager.validate_signature(message: message, queue: queue)
 
-        if(!EventQ::NonceManager.is_allowed?(message.id))
-          EventQ.logger.info("[#{self.class}] - Duplicate Message received. Ignoring message.")
-          return false
-        end
-
-        # begin worker block for queue message
-        begin
-          block.call(message.content, message_args)
+        status, message_args = context.process_message(block, message, retry_attempts, [poller, msg])
 
-          if message_args.abort == true
-            EventQ.logger.info("[#{self.class}] - Message aborted.")
+        case status
+          when :duplicate
+            # don't do anything, this is previous logic.  Not sure it is correct
+          when :accepted
+            # Acceptance was handled directly when QueueWorker#process_message was called
+          when :reject
+            reject_message(queue, poller, msg, retry_attempts, message, message_args.abort)
           else
-            # accept the message as processed
-            poller.delete_message(msg)
-            EventQ.logger.info("[#{self.class}] - Message acknowledged.")
-          end
-
-        rescue => e
-          EventQ.logger.error("[#{self.class}] - unhandled error while attempting to process a queue message")
-          EventQ.logger.error(e)
-          error = true
-          context.call_on_error_block(error: e, message: message)
-        end
-
-        if message_args.abort || error
-          EventQ::NonceManager.failed(message.id)
-          reject_message(queue, poller, msg, retry_attempts, message, message_args.abort)
-        else
-          EventQ::NonceManager.complete(message.id)
+            raise "Unrecognized status: #{status}"
         end
-
-        true
       end
 
       def reject_message(queue, poller, msg, retry_attempts, message, abort)
@@ -140,15 +114,16 @@ module EventQ
 
           EventQ.logger.info("[#{self.class}] - Message rejected requesting retry. Attempts: #{retry_attempts}")
 
+          retry_attempts = retry_attempts - queue.retry_back_off_grace
+          retry_attempts = 1 if retry_attempts < 1
+
           if queue.allow_retry_back_off == true
-            EventQ.logger.debug { "[#{self.class}] - Calculating message back off retry delay. Attempts: #{retry_attempts} * Delay: #{queue.retry_delay}" }
             visibility_timeout = (queue.retry_delay * retry_attempts) / 1000
             if visibility_timeout > (queue.max_retry_delay / 1000)
               EventQ.logger.debug { "[#{self.class}] - Max message back off retry delay reached." }
               visibility_timeout = queue.max_retry_delay / 1000
             end
           else
-            EventQ.logger.debug { "[#{self.class}] - Setting fixed retry delay for message." }
             visibility_timeout = queue.retry_delay / 1000
           end
 

data/lib/eventq/eventq_base/configuration.rb

@@ -6,11 +6,7 @@ module EventQ
     end
 
     def self.serialization_provider
-      if RUBY_PLATFORM =~ /java/
-        @serialization_provider ||= EventQ::SerializationProviders::JSON_PROVIDER
-      else
-        @serialization_provider ||= EventQ::SerializationProviders::OJ_PROVIDER
-      end
+      @serialization_provider ||= EventQ::SerializationProviders::OJ_PROVIDER
     end
 
     def self.signature_provider=(value)
@@ -30,4 +26,4 @@ module EventQ
     end
 
   end
-end
+end

data/lib/eventq/eventq_base/queue.rb

@@ -9,6 +9,7 @@ module EventQ
     attr_accessor :max_receive_count
     attr_accessor :require_signature
     attr_accessor :retry_delay
+    attr_accessor :retry_back_off_grace
 
     def initialize
       @allow_retry = false
@@ -22,6 +23,8 @@ module EventQ
       @require_signature = false
       # Default retry delay is 30 seconds
       @retry_delay = 30000
+      # This is the amount of times to allow retry to occurr before back off is implemented
+      @retry_back_off_grace = 0
     end
   end
 end

data/lib/eventq/eventq_base/serialization_providers.rb

@@ -1,8 +1,5 @@
 require_relative 'serialization_providers/json_serialization_provider'
-unless RUBY_PLATFORM =~ /java/
-  require_relative 'serialization_providers/oj_serialization_provider'
-end
-require_relative 'serialization_providers/jruby'
+require_relative 'serialization_providers/oj_serialization_provider'
 require_relative 'serialization_providers/binary_serialization_provider'
 
 module EventQ
@@ -15,11 +12,7 @@ module EventQ
     class Manager
       def initialize
         @providers = {}
-        if RUBY_PLATFORM =~ /java/
-          @providers[OJ_PROVIDER] = EventQ::SerializationProviders::JRuby::OjSerializationProvider
-        else
-          @providers[OJ_PROVIDER] = EventQ::SerializationProviders::OjSerializationProvider
-        end
+        @providers[OJ_PROVIDER] = EventQ::SerializationProviders::OjSerializationProvider
         @providers[JSON_PROVIDER] = EventQ::SerializationProviders::JsonSerializationProvider
         @providers[BINARY_PROVIDER] = EventQ::SerializationProviders::BinarySerializationProvider
       end

data/lib/eventq/eventq_rabbitmq/rabbitmq_queue_client.rb

@@ -39,12 +39,7 @@ module EventQ
       end
 
       def get_connection
-        if RUBY_PLATFORM =~ /java/
-          conn = MarchHare.connect(connection_options)
-        else
-          conn = Bunny.new(connection_options)
-        end
-
+        conn = Bunny.new(connection_options)
         conn.start
         return conn
       end

data/lib/eventq/eventq_rabbitmq/rabbitmq_queue_manager.rb

@@ -33,19 +33,11 @@ module EventQ
       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]
+        headers, properties, payload = queue.pop({ :manual_ack => true, :block => true })
+        if headers == nil
+          return [nil,nil]
         end
+        [headers.delivery_tag, payload]
       end
 
       def get_queue_exchange(channel, queue)

data/lib/eventq/eventq_rabbitmq/rabbitmq_queue_worker.rb

@@ -64,102 +64,68 @@ module EventQ
       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
+        # reject the message to remove from queue
         channel.reject(delivery_tag, false)
 
-        #check if the message retry limit has been exceeded
+        # 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)}")
 
           context.call_on_retry_exceeded_block(message)
-
-        #check if the message is allowed to be retried
+        # 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
+          retry_attempts = message.retry_attempts - queue.retry_back_off_grace
+          retry_attempts = 1 if 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
+            message_ttl = retry_attempts * queue.retry_delay
+            if (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." }
 
           context.call_on_retry_block(message)
-
         end
 
         return true
-
       end
 
       def configure(options = {})
         options[:durable] ||= true
       end
 
+      # Logic for the RabbitMq adapter when a message is accepted
+      def acknowledge_message(channel, delivery_tag)
+        channel.acknowledge(delivery_tag, false)
+      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}")
+        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,
-          id: message.id,
-          sent: message.created
-        )
-
-        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)
+        status, message_args = context.process_message(block, message, retry_attempts, [channel, delivery_tag])
 
-          if message_args.abort == true
-            abort = true
-            EventQ.logger.info("[#{self.class}] - Message aborted.")
-          else
-            # accept the message as processed
+        case status
+          when :duplicate
             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
-          context.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)
+          when :accepted
+            # Acceptance was handled directly when QueueWorker#process_message was called
+          when :reject
+            reject_message(channel, message, delivery_tag, retry_exchange, queue, message_args.abort)
+          else
+            raise "Unrecognized status: #{status}"
         end
       end
     end

data/lib/eventq/queue_worker.rb

@@ -54,7 +54,7 @@ module EventQ
           # So each fork gets its own copy of the @worker_status variable.
           track_process(pid)
         end
-        
+
         Process.waitall
       else
         # No need to track process/threads separately as we are in the main parent process,
@@ -108,6 +108,61 @@ module EventQ
       raise Exceptions::WorkerThreadError, e.message, e.backtrace
     end
 
+    # Method to be called by an adapter.  This defines the common logic for processing a message.
+    # @param [Array] acceptance_args list of arguments that would be used to accept a message by an adapter.
+    # @return [Symbol, MessageArgs] :accepted, :duplicate, :reject
+    def process_message(block, message, retry_attempts, acceptance_args)
+      abort = false
+      error = false
+      status = nil
+
+      message_args = EventQ::MessageArgs.new(
+          type: message.type,
+          retry_attempts: retry_attempts,
+          context: message.context,
+          content_type: message.content_type,
+          id: message.id,
+          sent: message.created
+      )
+
+      EventQ.logger.info("[#{self.class}] - Message received. Retry Attempts: #{retry_attempts}")
+
+      if (!EventQ::NonceManager.is_allowed?(message.id))
+        EventQ.logger.info("[#{self.class}] - Duplicate Message received. Ignoring message.")
+        status = :duplicate
+        return status, message_args
+      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
+          status = :accepted
+          worker_adapter.acknowledge_message(*acceptance_args)
+          EventQ.logger.info("[#{self.class}] - Message acknowledged.")
+        end
+      rescue => e
+        EventQ.logger.error("[#{self.class}] - Unhandled error while attempting to process a queue message.")
+        EventQ.logger.error(e)
+        error = true
+        call_on_error_block(error: e, message: message)
+      end
+
+      if error || abort
+        EventQ::NonceManager.failed(message.id)
+        status = :reject
+      else
+        EventQ::NonceManager.complete(message.id)
+      end
+
+      [status, message_args]
+    end
+
     def stop
       EventQ.logger.info("[#{self.class}] - Stopping.")
       @is_running = false

data/lib/eventq/rabbitmq.rb

@@ -1,20 +1,12 @@
 # require 'eventq_base'
 
-if RUBY_PLATFORM =~ /java/
-  require 'march_hare'
-else
-  require 'bunny'
-end
+require 'bunny'
 
 require 'hash_kit'
 require_relative './eventq_rabbitmq/rabbitmq_queue_client'
 require_relative './eventq_rabbitmq/rabbitmq_queue_manager'
 
-if RUBY_PLATFORM =~ /java/
-  require_relative './eventq_rabbitmq/jruby/rabbitmq_queue_worker'
-else
-  require_relative './eventq_rabbitmq/rabbitmq_queue_worker'
-end
+require_relative './eventq_rabbitmq/rabbitmq_queue_worker'
 
 require_relative './eventq_rabbitmq/rabbitmq_subscription_manager'
 require_relative './eventq_rabbitmq/rabbitmq_eventq_client'