banter 1.2.4 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07b71e3cd5e4d50cdbadff4bfc6aeb90cffa749c
-  data.tar.gz: 541920f865408bedb92d9b9bd0b0490adf7f13d1
+  metadata.gz: 20ba1b2e3b2fc1f89b3d25af6d5087e894ce4f87
+  data.tar.gz: bab54a9008cf00eb37f8c682a5c32ea199017f0c
 SHA512:
-  metadata.gz: 656c84442869c91309fcbb93c1303b527c4b03b107d53cc4354154928e7a0a0273e9e9ad5bdbeafc0b841141d8f7c94e40e5adb0b7cc43952db1a832cc8ade44
-  data.tar.gz: 943010a912bd147ca77ec5d5c6658b89688c74d2c4b194a9eee2bcbbd5777bbcf935e6cc19234a28c6ca7937dc4e500420b13891b59296371a0fb5b2adc17b53
+  metadata.gz: 1219d927b814c1ac6fdc88937d03082b757457c1a68bc454184d8adfb4c9c245b214d4faf886992a5a6fefd98dc1abcb7a7dc1613ca2344dcf0f3c1150119574
+  data.tar.gz: 7a303f0e8e01d9891811e8ad06dba142d0dcc4074c8e6c880627d0d313a0956f6122e2d4379433fc2b92532d9f7192388cbf2b52c548938c03dba8e14bc1e088

data/lib/banter/configuration.rb

@@ -13,11 +13,20 @@ module Banter
     mattr_accessor :exchange_name
     @@exchange_name = "banter"
 
+    mattr_accessor :dead_letter_exchange_name
+    @@dead_letter_exchange_name = "banter-dlx"
+
+    mattr_accessor :dead_letter_queue_name
+    @@dead_letter_queue_name = "deadletter"
+
     # The topic prefix for RabbitMQ
     # @default banter
     mattr_accessor :topic_prefix
     @@topic_prefix = "banter"
 
+    mattr_accessor :durable_queues
+    @@durable_queues = true
+
     mattr_accessor :logger
 
     # RabbitMQ push and subscribe logging toggle
@@ -35,10 +44,6 @@ module Banter
     mattr_accessor :batch_messages
     @@batch_messages = false
 
-    # Dead letter queue name
-    # @default nil
-    mattr_accessor :dead_letter_queue
-
     # Enable web monitoring
     # @default false
     mattr_accessor :web_enabled

data/lib/banter/message.rb

@@ -10,6 +10,8 @@ module Banter
     attr_reader :version
     attr_reader :payload
     attr_reader :context
+    attr_reader :dead_letter
+    attr_reader :envelope
 
     def initialize
     end
@@ -21,19 +23,26 @@ module Banter
       @version = @@message_version
       @payload = payload
       @context = context
+      @dead_letter = nil
       to_hash
     end
 
     def parse(envelope)
       contents = Hashie::Mash.new(::JSON.parse(envelope))
+      from_hash(contents)
+      to_hash
+    end
+
+    def from_hash(contents)
       @ts = contents.ts
       @pub = contents.pub
       # Version used for messaging can get updated if we need to add extra header information, and need
       # to move each section of the library separately.
       @version = contents.v
       @payload = contents.payload
+      @dead_letter = contents.dead_letter
       @context = ::Banter::Context.from_json(contents[:context])
-      to_hash
+      self
     end
 
     def to_hash
@@ -42,8 +51,14 @@ module Banter
         pub: @pub,
         v: @@message_version,
         payload: @payload,
+        dead_letter: @dead_letter,
         context: @context.as_json
       })
+
+    end
+
+    def retry_completed?
+      @dead_letter.present? && @dead_letter.completed.present? && @dead_letter.completed > 0
     end
 
   end

data/lib/banter/publisher.rb

@@ -12,8 +12,14 @@ module Banter
       @@publisher
     end
 
-    def initialize(exchange = nil)
+    def self.teardown
+      @@publisher.teardown if @publisher
+      @@publisher = nil
+    end
+
+    def initialize(exchange = nil, exchange_type = :topic)
       @exchange = exchange || Banter::Configuration.exchange_name
+      @exchange_type = exchange_type
       @disabled = false
       @batch_messages = false
       @stack_depth = 0
@@ -43,7 +49,7 @@ module Banter
         @connection.start
 
         @channel   = @connection.create_channel
-        @publisher = @channel.topic(@exchange, :durable => true, :auto_delete => false)
+        @publisher = @channel.send(@exchange_type, @exchange, :durable => true, :auto_delete => false)
 
       rescue => e
         Airbrake.notify(e, parameters: { message: e.message }, environment_name: ENV['RAILS_ENV'])
@@ -68,8 +74,20 @@ module Banter
       end
     end
 
-   private
-   def execute_publish(routing_key, envelope)
+    # Special method to publish to specific queues.  This is useful for deadletter queue processing, where the dead letter will want to
+    # fire a message to a specific queue, as well at the consumer will want to inform the dead letter queue that it is finished processing
+    # a retry
+    # @param queue_name [String] name to publish to (can be retrieved from headers[:x_death][:queue] from dead letter exchange processor)
+    # @param envelope [Hash] hash of contents that the amqp server returns
+    def publish_to_queue(queue_name, envelope)
+      execute_publish(queue_name, envelope, true)
+    end
+
+    # Calls the ampq server with normalized data
+    # @param routing_key [String] - routing_key that amqp server uses
+    # @param envelope [Hash] - normalized data to publish
+   def execute_publish(routing_key, envelope, use_default_exchange=false)
+
 
       if @publisher.nil?
         start
@@ -80,7 +98,8 @@ module Banter
       else
         tries = 2
         begin
-          @publisher.publish(envelope.to_json, :persistent => true, :mandatory => true, :timestamp => envelope[:ts], :content_type => "application/json", :routing_key => routing_key)
+          instance = use_default_exchange ? @channel.default_exchange : @publisher
+          instance.publish(envelope.to_json, :persistent => true, :mandatory => true, :timestamp => envelope[:ts], :content_type => "application/json", :routing_key => routing_key)
           Banter::RabbitLogger.log_publish(routing_key, envelope)
         # FIX!!! -thl
         # What kind of errors could be fired from a failure to publish?
@@ -103,6 +122,7 @@ module Banter
 
     end
 
+  private
     def teardown
       begin
         @connection.close

data/lib/banter/rabbit_logger.rb

@@ -36,8 +36,8 @@ module Banter
     end
 
     def self.log(log_level, message)
-      tags = ["BANTER LOG_LEVEL:#{@@log_map[log_level].capitalize.to_s}", Process::pid.to_s].map{|x| utf(x)}
-      logger.tagged(tags) { logger.send(@@log_map[log_level], utf(message.as_json.to_s) ) }
+      tags = ["BANTER LOG_LEVEL:#{@@log_map[log_level].capitalize.to_s}", Process::pid]
+      logger.tagged(tags) { logger.send(@@log_map[log_level], message.as_json ) }
     end
 
     def self.internal_log(log_level, log_type, envelope, routing_key, payload)

data/lib/banter/server/client_queue_listener.rb

@@ -10,12 +10,9 @@ module Banter
 
       attr_reader :worker_class
 
-      def initialize(worker_class, request_key, queue_name, durable = true, pool_size = 100, topic = nil)
-        @topic        = topic || Banter::Configuration.topic_prefix
-        @request_key  = request_key
+      def initialize(worker_class)
         @worker_class = worker_class
-        @queue_name   = queue_name
-        @subscriber   = ::Banter::Server::RabbitMQSubscriber.new(@request_key, @queue_name, worker_class.queue_ttl, durable, pool_size, @topic)
+        @subscriber   = RabbitMQSubscriber.new(worker_class.config)
       end
 
       def start
@@ -31,11 +28,12 @@ module Banter
 
       def message_received(delivery_info, properties, envelope)
         Banter::RabbitLogger.log(::Logger::DEBUG, "Message received by listener on #{worker_class.name} with payload: #{envelope[:payload]}")
-        worker  = worker_class.new(delivery_info, properties, envelope[:context])
+        worker  = worker_class.new(delivery_info, properties, envelope[:context], envelope)
         payload = envelope[:payload]
         track_message_received(worker, payload)
         worker.perform!(payload)
         track_message_successful
+        clear_dead_letter(worker_class.config.dead_letter_queue_name, envelope)
       rescue ::Banter::PayloadValidationError => banter_error
         track_message_failed(banter_error, false)
         Banter::RabbitLogger.log(::Logger::ERROR, { worker: worker_class.name, message: banter_error.message, envelope: envelope })
@@ -47,6 +45,7 @@ module Banter
                           payload:    envelope[:payload],
                           message:    "Validation error for #{worker_class.name}"
                         })
+        raise banter_error
       rescue => e
         track_message_failed(e, true)
         Banter::RabbitLogger.log(::Logger::DEBUG, "Failed message for #{worker_class.name} #{e.message}")
@@ -58,7 +57,14 @@ module Banter
                           payload:    envelope[:payload],
                           message:    "Failed perform for #{worker_class.name}"
                         })
+        raise e
+      end
 
+      def clear_dead_letter(dead_letter_queue, envelope)
+        if !dead_letter_queue.blank? && !envelope[:dead_letter].blank?
+          envelope.dead_letter.completed = 1
+          Banter::Publisher.instance.publish_to_queue(dead_letter_queue, envelope)
+        end
       end
 
       protected

data/lib/banter/server/rabbit_mq_subscriber.rb

@@ -8,21 +8,26 @@ module Banter
       attr_reader :exchange
       attr_reader :channel
       attr_reader :ttl
-
-      def initialize(routing_key, queue_name, ttl, durable = true, pool_size = 100, topic = Banter::Configuration.topic_prefix)
-        @initial_key = routing_key
-        @durable     = durable
-        @topic       = topic
-        @ttl         = ttl
-        @pool_size   = pool_size
-
-        if @initial_key.present?
+      attr_reader :routing_key
+      attr_reader :topic
+
+      def initialize(config)
+        @topic       = config.topic
+        @exchange_name = config.exchange
+        @dead_letter_exchange_name = config.dead_letter_exchange
+        @initial_key = config.routing_key
+        @queue_name  = config.queue_name
+        @ttl         = config.ttl
+        @durable     = config.durable
+        @pool_size   = config.pool_size
+        if @topic.blank?
+          @routing_key = "#"
+        elsif @initial_key.present?
           @routing_key = "#{@topic}.#{@initial_key}.#"
-        else
+        elsif @topic.present?
           @routing_key = "#{@topic}.#"
         end
 
-        @queue_name = queue_name
       end
 
       def start(&block)
@@ -36,11 +41,13 @@ module Banter
         end
 
         @channel  = @connection.create_channel
-        @exchange = @channel.topic(@topic, :durable => @durable, :auto_delete => false)
+
+        @exchange = @channel.topic(@exchange_name, :durable => @durable, :auto_delete => false)
 
         queue_arguments                           = {}
-        queue_arguments["x-dead-letter-exchange"] = Configuration.dead_letter_queue if Configuration.dead_letter_queue.present?
-        queue_arguments["x-message-ttl"]          = ttl * 1000
+
+        queue_arguments["x-dead-letter-exchange"] = @dead_letter_exchange_name if @dead_letter_exchange_name.present?
+        queue_arguments["x-message-ttl"]          = ttl * 1000 if ttl > 0
 
         @channel.basic_qos(@pool_size) if @pool_size != 0
 
@@ -76,7 +83,6 @@ module Banter
           Banter::RabbitLogger.log(Logger::WARN, "Error in message: #{e}")
           e.backtrace.each{|line| Banter::RabbitLogger.log(Logger::WARN, "-- #{line}") }
           Banter::RabbitLogger.log(Logger::WARN, "contents: #{contents}")
-          Banter::RabbitLogger.log(Logger::WARN, { routing_key: delivery_info[:routing_key], delivery_info: delivery_info, properties: properties, envelope: envelope} )
           Banter::RabbitLogger.log_subscriber_failed(delivery_info[:routing_key], delivery_info, properties, envelope)
 
           # Does not get put back on the queue, and instead, will need to be processed either by the log parser

data/lib/banter/server/subscriber_server.rb

@@ -79,7 +79,7 @@ module Banter
 
       def start_workers
         workers.each do |worker|
-          puts "starting workers"
+          puts "starting worker #{worker.inspect}"
           worker.start
         end
       end
@@ -94,15 +94,8 @@ module Banter
         @hostname     = `hostname -f`.chomp
       end
 
-      def create_queue_listeners(subscriber)
-        application_name = Banter::Configuration.application_name
-        routing_key      = subscriber.subscribed_key
-        durable          = subscriber.durable
-        queue_name       = subscriber.generated_queue_name(routing_key, application_name)
-        pool_size        = Banter::Configuration.configuration[:pool_size] || 100
-
-        STDOUT.puts "Setting up listener for request_key: #{routing_key} and queue:#{application_name} with qos setting: #{pool_size}"
-        ClientQueueListener.new(subscriber, routing_key, queue_name, durable, pool_size)
+      def create_queue_listeners(subscriber_class)
+        ClientQueueListener.new(subscriber_class)
       end
     end
   end

data/lib/banter/subscriber.rb

@@ -8,8 +8,8 @@ module Banter
   class Subscriber
     @@registered_subscribers = []
 
-    class_attribute :payload_validators, :error_handlers, :subscribed_key, :subscribed_queue, :queue_ttl, :application_name, :durable
-    attr_accessor :delivery_routing_data, :delivery_properties, :context
+    class_attribute :payload_validators, :error_handlers, :config, :subscribed_key, :subscribed_queue
+    attr_accessor :delivery_routing_data, :delivery_properties, :context, :envelope
 
     def self.inherited(klass)
       @@registered_subscribers << klass
@@ -19,19 +19,55 @@ module Banter
     # @param [String] routing_key_name The routing key to subscribe to. Must be characters only separated by periods (.)
     # @param [Hash] options subscription options
     #   @option [String] :durable sets the subscriber to be a durable subscriber (one that survives reboots).  This currently defaults to true.
-    #   @option [Integer] :queue_ttl Time, in seconds, that the message lives on the queue before being either consumer by a subscriber or being discarded.
+    #   @option [Integer] :ttl Time, in seconds, that the message lives on the queue before being either consumer by a subscriber or being discarded.
     #                                If not specified, then Banter::Configuration.default_queue_ttl is used
-
+    #   @option [String] :exchange_name sets to exchange to the specified value, or if it is not used, will default to Banter.Configuration.exchange_name
+    #   @option [String] :dead_letter_exchange_name name of queue to subscribe to.
+    #   @option [String] :queue_name name of queue to subscribe to.
     def self.subscribe_to(routing_key_name, options = {})
-      options.assert_valid_keys(:durable, :queue_ttl)
+
       unless validate_routing_key_name(routing_key_name)
         raise ArgumentError.new("#{routing_key_name} is not supported. Only lower case characters separated by periods are allowed.")
       end
-      self.subscribed_key   = routing_key_name
-      self.application_name = generated_application_name(options[:on])
-      self.subscribed_queue = generated_queue_name(routing_key_name, self.application_name)
-      self.queue_ttl        = options[:queue_ttl] || Banter::Configuration.default_queue_ttl
-      self.durable         = options.key?(:durable) ? options[:durable] : true
+
+      options.assert_valid_keys(
+        :topic_prefix,
+        :exchange_name,
+        :dead_letter_exchange_name,
+        :dead_letter_queue_name,
+        :queue_name,
+        :ttl,
+        :durable,
+        :pool_size)
+
+      config = Hashie::Mash.new
+      config[:topic]          = get_config_value(options, :topic_prefix)
+      config[:exchange]       = get_config_value(options, :exchange_name)
+      config[:dead_letter_exchange] = get_config_value(options, :dead_letter_exchange_name)
+      config[:dead_letter_queue_name] = get_config_value(options, :dead_letter_queue_name)
+      config[:routing_key]    = self.subscribed_key = routing_key_name
+      config[:queue_name]     = self.subscribed_queue = options[:queue_name] || generated_queue_name(routing_key_name, Banter::Configuration.application_name)
+      config[:ttl]            = get_config_value(options, :ttl, :default_queue_ttl)
+      config[:durable]        = get_config_value(options, :durable, :durable_queues)
+      config[:pool_size]      = get_config_value(options, :pool_size)
+
+      self.config = config
+
+    end
+
+    def self.get_config_value(options, options_key, config_key = nil)
+      if options.key?(options_key)
+        options[options_key]
+      else
+        config_key = options_key if config_key.nil?
+        configure_obj = [Banter::Configuration.configuration, Banter::Configuration].find do |obj|
+          obj.respond_to?(config_key)
+        end
+        configure_obj.nil? ? nil : configure_obj.send(config_key)
+      end
+    rescue => e
+      puts "Banter Configuration does not exist #{config_key}:#{e.message}"
+      raise e
     end
 
     # Sets the validator for payload
@@ -49,13 +85,15 @@ module Banter
       error_handler = handler
     end
 
-    # @param [Hash] context Context from invocation
     # @param [Object] delivery_routing_data Contains routing information like originator and routing key
     # @param [Object] delivery_properties
-    def initialize(delivery_routing_data, delivery_properties, context)
+    # @param [Hash] context
+    # @param [Hash] envelope
+    def initialize(delivery_routing_data, delivery_properties, context, envelope)
       @delivery_routing_data = delivery_routing_data
       @delivery_properties   = delivery_properties
       @context               = context
+      @envelope              = envelope
     end
 
     # Performs validation if validates_payload_with is defined and then calls the perform method

data/lib/banter/version.rb

@@ -1,3 +1,3 @@
 module Banter
-  VERSION = "1.2.4"
+  VERSION = "1.3.0"
 end

data/spec/banter/message_spec.rb

@@ -37,29 +37,69 @@ describe Banter::Message do
     let(:payload) { subject.serialize(context, routing_key, original).to_json }
     let(:result) { subject.parse(payload) }
 
-    it "should not fail" do
-      expect{ result }.not_to raise_error()
-    end
+    context "standard message" do
+      it "should not fail" do
+        expect{ result }.not_to raise_error()
+      end
 
-    it "should have all the hash items" do
-      expect(result[:ts]).not_to be_nil
-      expect(result[:v]).not_to be_nil
-      expect(result[:pub]).not_to be_nil
-      expect(result[:payload]).not_to be_nil
-    end
+      it "should have all the hash items" do
+        expect(result[:ts]).not_to be_nil
+        expect(result[:v]).not_to be_nil
+        expect(result[:pub]).not_to be_nil
+        expect(result[:payload]).not_to be_nil
+        expect(result[:dead_letter]).to be_nil
+        expect(subject.retry_completed?).to eq(false)
+      end
 
-    it "should have the data in the payload" do
-      expect(result.payload.data).to eq('found')
-    end
+      it "should have the data in the payload" do
+        expect(result.payload.data).to eq('found')
+      end
 
-    it "should have the attributes readable" do
-      result
-      expect(subject.ts).not_to be_nil
-      expect(subject.version).not_to be_nil
-      expect(subject.pub).not_to be_nil
-      expect(subject.payload).not_to be_nil
+      it "should have the attributes readable" do
+        result
+        expect(subject.ts).not_to be_nil
+        expect(subject.version).not_to be_nil
+        expect(subject.pub).not_to be_nil
+        expect(subject.payload).not_to be_nil
+        expect(subject.dead_letter).to be_nil
+      end
     end
 
+    context "dead lettered message" do
+      let(:complete_val) { 1 }
+      let(:payload) do
+        obj = subject.serialize(context, routing_key, original)
+        obj.dead_letter = {"completed"=> complete_val, "id"=> 5}
+        obj.to_json
+      end
+
+      before do
+        result
+      end
+
+      context "completed message" do
+        it "should have all the hash items" do
+          expect(result[:ts]).not_to be_nil
+          expect(result[:v]).not_to be_nil
+          expect(result[:pub]).not_to be_nil
+          expect(result[:payload]).not_to be_nil
+          expect(result[:dead_letter]).not_to be_nil
+          expect(subject.retry_completed?).to eq(true)
+        end
+      end
+
+      context "failed message" do
+        let(:complete_val) { 0 }
+        it "should have all the hash items" do
+          expect(result[:ts]).not_to be_nil
+          expect(result[:v]).not_to be_nil
+          expect(result[:pub]).not_to be_nil
+          expect(result[:payload]).not_to be_nil
+          expect(result[:dead_letter]).not_to be_nil
+          expect(subject.retry_completed?).to eq(false)
+        end
+      end
+    end
   end
 
 end

data/spec/banter/server/client_queue_listener_spec.rb

@@ -1,10 +1,26 @@
 require 'spec_helper'
 
+
+class TestSubscriber < Banter::Subscriber
+  subscribe_to "some.test.key"
+end
+
 describe Banter::Server::ClientQueueListener do
   describe "#message_received" do
 
     subject { -> { queue_listener.message_received({}, { routing_key: routing_key }, { context: context, payload: payload }) } }
-    let(:queue_listener) { Banter::Server::ClientQueueListener.new(Klass, routing_key, 'queue') }
+    let(:subscriber_config) { Hashie::Mash.new(
+      topic: "banter",
+      exchange: "banter",
+      dead_letter_exchange: "banter-dlx",
+      routing_key: routing_key,
+      queue_name: "test_queue",
+      ttl: 100,
+      durable: true,
+      pool_size: 100
+    )}
+
+    let(:queue_listener) { Banter::Server::ClientQueueListener.new(Klass) }
     let(:routing_key) { 'some.test.key' }
     let(:context) { { app: 'test' } }
     let(:payload) { { hello: 'moto' } }
@@ -17,6 +33,7 @@ describe Banter::Server::ClientQueueListener do
     }
     let!(:application_name) { "testapplication" }
     let(:banter_message) { BanterMessage.last }
+    let(:subscriber_options) {{}}
 
     after(:each) { Banter::Configuration.web_enabled = false }
 
@@ -46,25 +63,36 @@ describe Banter::Server::ClientQueueListener do
       validators.each do |validator|
         Klass.validates_payload_with validator
       end
-      Klass.subscribe_to "test.foo"
+      Klass.subscribe_to "test.foo", subscriber_options
 
       klass_instance
 
       allow(Klass).to receive(:new).and_return(klass_instance)
-      subject.call unless respond_to? :no_call
     end
 
     after do
       Object.send :remove_const, :Klass
     end
 
+    def safe_call
+      subject.call
+    rescue=>e
+      @raised_error = e
+      nil
+    end
+
     context "Normal execution" do
       let!(:klass_instance) {
-        instance = Klass.new({}, {}, {})
+        instance = Klass.new({}, {}, {}, {})
         allow(instance).to receive(:perform!)
         instance
       }
 
+
+      before do
+        subject.call unless respond_to? :no_call
+      end
+
       context "banter web disabled" do
         context "test exception" do
           let(:no_call) { true }
@@ -94,7 +122,7 @@ describe Banter::Server::ClientQueueListener do
 
     context "Exception during execution" do
       let!(:klass_instance) {
-        instance = Klass.new({}, {}, {})
+        instance = Klass.new({}, {}, {}, {})
         allow(instance).to receive(:perform!) {
           raise StandardError.new("test exception")
         }
@@ -105,29 +133,42 @@ describe Banter::Server::ClientQueueListener do
         before do
           allow(Banter::RabbitLogger).to receive(:log)
         end
-        it { should_not raise_exception }
+        it { should raise_exception }
         it { expect(BanterMessage.count).to eq(0) }
       end
 
       context "banter web enabled" do
         let(:context_before) { enable_banter_web }
 
-        it { should_not raise_exception }
-        it { expect(klass_instance).to have_received(:perform!).with(payload) }
+        before do
+          safe_call
+        end
+
+        it { should raise_exception }
+        it "should have called perform" do
+          expect(klass_instance).to have_received(:perform!).with(payload)
+        end
         banter_message_fields_are_correct(BanterMessage::STATUS_ERROR, 'test exception')
       end
     end
 
     context "Payload error" do
       let!(:klass_instance) {
-        instance = Klass.new({}, {}, {})
+        instance = Klass.new({}, {}, {},{})
         allow(instance).to receive(:perform!).and_raise(Banter::PayloadValidationError.new("validation failed"))
         instance
       }
 
+      let(:result) { subject.call }
+
+      before do
+        safe_call
+      end
+
       let!(:validators) { [lambda { |payload| false }] }
       context "web disabled" do
         let(:context_before) { allow(Airbrake).to receive(:notify) }
+        it { should raise_exception }
         it { expect(Airbrake).to have_received(:notify) }
       end
 
@@ -138,10 +179,49 @@ describe Banter::Server::ClientQueueListener do
         end
 
         it { expect(Airbrake).to have_received(:notify) }
-        it { should_not raise_exception }
+        it { should raise_exception }
         it { expect(klass_instance).to have_received(:perform!).with(payload) }
         banter_message_fields_are_correct(BanterMessage::STATUS_VALIDATION_FAILED, "validation failed")
       end
     end
+
+    context "reprocessing message" do
+      subject { -> { queue_listener.message_received({}, { routing_key: routing_key }, Hashie::Mash.new({ context: context, payload: payload, dead_letter: { retries: 1, id: 553} }) ) } }
+      let(:subscriber_options) {{ dead_letter_queue_name: "deadletter" }}
+      let(:test_method) { raise StandardError.new("test exception") }
+      let!(:klass_instance) {
+        instance = Klass.new({}, {}, {}, {})
+        allow(instance).to receive(:perform!) {
+          test_method
+        }
+        instance
+      }
+
+      before do
+        klass_instance
+        allow(Banter::Publisher.instance).to receive(:execute_publish)
+        safe_call
+      end
+
+      context "succeed in reprocess" do
+        let(:test_method) { {} }
+
+        it "should have called the execute_publish method of the queue publisher" do
+          # Marked the message with a completed flag and send to a queue for dead letter.  also, the exchange is correct being empty.
+          hash_data = { context: {app:"test"}, dead_letter: { completed: 1,  id: 553, retries: 1 }, payload: { hello: "moto"} }
+          val = Hashie::Mash.new(hash_data)
+          expect(Banter::Publisher.instance).to have_received(:execute_publish).with("deadletter", val, true )
+        end
+
+      end
+
+      context "failed to reprocess" do
+        it "should not have called the execute_publish method of the queue publisher" do
+          expect(Banter::Publisher.instance).not_to have_received(:execute_publish)
+        end
+
+      end
+
+    end
   end
 end

data/spec/banter/server/rabbitmq_subscriber_spec.rb

@@ -1,8 +1,19 @@
 require 'spec_helper'
 
+
 describe Banter::Server::RabbitMQSubscriber do
   let(:routing_key) { "fake.route"}
-  let(:subscriber){ Banter::Server::RabbitMQSubscriber.new( routing_key, "queue_name", 100 ) }
+  let(:subscriber_config) { Hashie::Mash.new(
+    topic: "banter",
+    exchange: "banter",
+    dead_letter_exchange: "banter-dlx",
+    routing_key: routing_key,
+    queue_name: "test_queue",
+    ttl: 100,
+    durable: true,
+    pool_size: 100
+  )}
+  let(:subscriber){ Banter::Server::RabbitMQSubscriber.new( subscriber_config ) }
   let(:delivery_info) { Hashie::Mash.new({ :delivery_tag=>1, :routing_key=> routing_key}) }
   let(:properties) { {} }
   let(:contents) { File.read( File.join(File.dirname(__FILE__), "../../fixtures/utf_message.json")) }

data/spec/banter/server/subscriber_server_spec.rb

@@ -20,8 +20,8 @@ describe Banter::Server::SubscriberServer do
       }
 
       it "creates queue listeners" do
-        expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber1, "foo.bar.one", "foo.bar.one_#{application_name}", durable, 100)
-        expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber2, "foo.bar.two", "foo.bar.two_#{application_name}", durable, 100)
+        expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber1)
+        expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber2)
       end
     end
 
@@ -39,8 +39,8 @@ describe Banter::Server::SubscriberServer do
       }
 
       it "creates queue listeners" do
-        expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber1, "foo.bar.one", "foo.bar.one_#{application_name}", durable, 200)
-        expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber2, "foo.bar.two", "foo.bar.two_#{application_name}", durable, 200)
+        expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber1)
+        expect(Banter::Server::ClientQueueListener).to have_received(:new).with(MyTestSubscriber2)
       end
 
     end

data/spec/banter/subscriber_spec.rb

@@ -10,7 +10,7 @@ describe Banter::Subscriber do
   end
 
   describe "#routing_key" do
-    subject { Banter::Subscriber.new(routing_data, properties, {}).routing_key }
+    subject { Banter::Subscriber.new(routing_data, properties, {}, {}).routing_key }
 
     let(:properties) { {} }
 
@@ -22,7 +22,7 @@ describe Banter::Subscriber do
   end
 
   describe '#at' do
-    let(:subscriber) { Banter::Subscriber.new({}, {}, {}) }
+    let(:subscriber) { Banter::Subscriber.new({}, {}, {}, {}) }
     context 'web not enabled' do
       before do
         allow(Banter::Configuration).to receive(:web_enabled).and_return(false)
@@ -49,7 +49,7 @@ describe Banter::Subscriber do
   end
 
   describe '#total' do
-    let(:subscriber) { Banter::Subscriber.new({}, {}, {}) }
+    let(:subscriber) { Banter::Subscriber.new({}, {}, {}, {}) }
     context 'web not enabled' do
       before do
         allow(Banter::Configuration).to receive(:web_enabled).and_return(false)
@@ -76,7 +76,7 @@ describe Banter::Subscriber do
   end
 
   describe '#progress' do
-    let(:subscriber) { Banter::Subscriber.new({}, {}, {}) }
+    let(:subscriber) { Banter::Subscriber.new({}, {}, {}, {}) }
     context 'web not enabled' do
       before do
         allow(Banter::Configuration).to receive(:web_enabled).and_return(false)
@@ -112,18 +112,18 @@ describe Banter::Subscriber do
     context "One validator" do
       let(:validators){ [lambda{|payload| true}] }
       it {
-        expect(Klass.new({},{}, {}).payload_validators.length).to eq 1 }
+        expect(Klass.new({},{}, {}, {}).payload_validators.length).to eq 1 }
     end
 
     context "Two validators" do
       let(:validators){ [lambda{|payload| true}, lambda{|payload| true}] }
-      it { expect(Klass.new({},{}, {}).payload_validators.length).to eq 2  }
+      it { expect(Klass.new({},{}, {}, {}).payload_validators.length).to eq 2  }
     end
   end
 
   describe '#valid_payload?' do
     context
-    subject { Klass.new({},{}, {}).valid_payload?({}) }
+    subject { Klass.new({},{}, {},{}).valid_payload?({}) }
 
     before do
       validators.each do |validator|
@@ -222,7 +222,7 @@ describe Banter::Subscriber do
       before { Klass.subscribe_to 'a.b.c' }
       it 'sets the routing key and queue name' do
         expect(Klass.subscribed_key).to eq('a.b.c')
-        expect(Klass.subscribed_queue).to eq('a.b.c_app_name')
+        expect(Klass.config[:queue_name]).to eq('a.b.c_app_name')
       end
     end
 
@@ -230,7 +230,7 @@ describe Banter::Subscriber do
       before { Klass.subscribe_to 'a.b.c' }
       it 'sets the routing key and queue name' do
         expect(Klass.subscribed_key).to eq('a.b.c')
-        expect(Klass.subscribed_queue).to eq('a.b.c_app_name')
+        expect(Klass.config[:queue_name]).to eq('a.b.c_app_name')
       end
     end
 
@@ -238,7 +238,7 @@ describe Banter::Subscriber do
       before { Klass.subscribe_to 'a_b.c' }
       it 'is allowed' do
         expect(Klass.subscribed_key).to eq('a_b.c')
-        expect(Klass.subscribed_queue).to eq('a_b.c_app_name')
+        expect(Klass.config[:queue_name]).to eq('a_b.c_app_name')
       end
     end
 
@@ -252,16 +252,16 @@ describe Banter::Subscriber do
 
     context "queue_ttl" do
       context "option provided" do
-        before { Klass.subscribe_to "a.b", queue_ttl: 4 }
+        before { Klass.subscribe_to "a.b", ttl: 4 }
         it 'sets the ttl' do
-          expect(Klass.queue_ttl).to eq(4)
+          expect(Klass.config[:ttl]).to eq(4)
         end
       end
 
       context "option not provided" do
         before { Klass.subscribe_to "a.b" }
         it 'uses default' do
-          expect(Klass.queue_ttl).to eq(Banter::Configuration.default_queue_ttl)
+          expect(Klass.config[:ttl]).to eq(Banter::Configuration.default_queue_ttl)
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: banter
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.3.0
 platform: ruby
 authors:
 - The Honest Company
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-09 00:00:00.000000000 Z
+date: 2014-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler