hutch 0.25.0-java → 2.0.0.rc1-java

data/lib/hutch/tracers/datadog.rb

@@ -0,0 +1,18 @@
+require 'datadog'
+require 'datadog/auto_instrument'
+
+module Hutch
+  module Tracers
+    class Datadog
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def handle(message)
+        ::Datadog::Tracing.trace(@klass.class.name, continue_from: nil, service: 'hutch', type: 'rabbitmq') do
+          @klass.process(message)
+        end
+      end
+    end
+  end
+end

data/lib/hutch/tracers.rb

@@ -2,6 +2,6 @@ module Hutch
   module Tracers
     autoload :NullTracer, 'hutch/tracers/null_tracer'
     autoload :NewRelic,   'hutch/tracers/newrelic'
-    autoload :Opbeat,     'hutch/tracers/opbeat'
+    autoload :Datadog,    'hutch/tracers/datadog'
   end
 end

data/lib/hutch/version.rb

@@ -1,4 +1,3 @@
 module Hutch
-  VERSION = '0.25.0'.freeze
+  VERSION = '2.0.0.rc1'.freeze
 end
-

data/lib/hutch/worker.rb

@@ -11,8 +11,9 @@ module Hutch
     include Logging
 
     def initialize(broker, consumers, setup_procs)
-      @broker        = broker
-      self.consumers = consumers
+      @broker         = broker
+      @recovery_lock  = Mutex.new
+      self.consumers  = consumers
       self.setup_procs = setup_procs
     end
 
@@ -45,17 +46,53 @@ module Hutch
     # Bind a consumer's routing keys to its queue, and set up a subscription to
     # receive messages sent to the queue.
     def setup_queue(consumer)
-      logger.info "setting up queue: #{consumer.get_queue_name}"
+      queue_name = consumer.get_queue_name
+      queue_name = @broker.namespaced_queue_name(queue_name) unless consumer.without_namespace?
+      logger.info "setting up queue: #{queue_name}"
 
-      queue = @broker.queue(consumer.get_queue_name, consumer.get_arguments)
+      queue = @broker.queue(queue_name, consumer.get_options)
       @broker.bind_queue(queue, consumer.routing_keys)
 
-      queue.subscribe(consumer_tag: unique_consumer_tag, manual_ack: true) do |*args|
+      on_cancellation = proc { handle_cancellation(queue_name, queue.channel) }
+      queue.subscribe(consumer_tag: unique_consumer_tag, manual_ack: true,
+                      on_cancellation: on_cancellation) do |*args|
         delivery_info, properties, payload = Hutch::Adapter.decode_message(*args)
         handle_message(consumer, delivery_info, properties, payload)
       end
     end
 
+    # A server-sent `basic.cancel` carries no reason, so a consumer timeout
+    # is indistinguishable from a queue deletion. Only the former is recoverable.
+    def handle_cancellation(queue_name, cancelled_channel)
+      unless @broker.queue_exists?(queue_name)
+        logger.error "consumer on queue #{queue_name} was cancelled by the server: the queue no longer exists"
+        return
+      end
+
+      logger.warn "consumer on queue #{queue_name} was cancelled by the server, re-subscribing"
+      resubscribe_on_a_new_channel(cancelled_channel)
+    rescue => ex
+      logger.error "consumer re-subscription failed: #{ex.class}: #{ex.message}"
+    end
+
+    # Runs on its own thread: closing the channel kills the consumer work
+    # pool this callback runs on. Returns the thread so that tests can join it.
+    def resubscribe_on_a_new_channel(cancelled_channel)
+      Thread.new do
+        begin
+          @recovery_lock.synchronize do
+            # All consumers share the channel, so only the first cancellation replaces it.
+            next unless @broker.channel.equal?(cancelled_channel)
+
+            @broker.replace_channel!
+            setup_queues
+          end
+        rescue => ex
+          logger.error "consumer re-subscription failed: #{ex.class}: #{ex.message}"
+        end
+      end
+    end
+
     # Called internally when a new messages comes in from RabbitMQ. Responsible
     # for wrapping up the message and passing it to the consumer.
     def handle_message(consumer, delivery_info, properties, payload)
@@ -71,10 +108,10 @@ module Hutch
       message = Message.new(delivery_info, properties, payload, serializer)
       consumer_instance = consumer.new.tap { |c| c.broker, c.delivery_info = @broker, delivery_info }
       with_tracing(consumer_instance).handle(message)
-      @broker.ack(delivery_info.delivery_tag)
+      @broker.ack(delivery_info.delivery_tag, channel: delivery_info.channel) unless consumer_instance.message_rejected?
     rescue => ex
       acknowledge_error(delivery_info, properties, @broker, ex)
-      handle_error(properties, payload, consumer, ex)
+      handle_error(properties, payload, consumer, ex, delivery_info)
     end
 
     def with_tracing(klass)
@@ -83,7 +120,7 @@ module Hutch
 
     def handle_error(*args)
       Hutch::Config[:error_handlers].each do |backend|
-        backend.handle(*args)
+        backend.handle *args.first(backend.method(:handle).arity)
       end
     end
 
@@ -118,7 +155,7 @@ module Hutch
     def group_restricted?(consumer)
       consumers_to_load = consumer_groups[group]
       if consumers_to_load
-        !allowed_consumers.include?(consumer.name)
+        !consumers_to_load.include?(consumer.name)
       else
         true
       end

data/lib/hutch.rb

@@ -14,6 +14,8 @@ require 'hutch/exceptions'
 require 'hutch/tracers'
 
 module Hutch
+  @@connection_mutex = Mutex.new
+
   def self.register_consumer(consumer)
     self.consumers << consumer
   end
@@ -40,10 +42,12 @@ module Hutch
   # @param config [Hash] Configuration
   # @option options [Boolean] :enable_http_api_use
   def self.connect(options = {}, config = Hutch::Config)
-    return if connected?
-
-    @broker = Hutch::Broker.new(config)
-    @broker.connect(options)
+    @@connection_mutex.synchronize do
+      unless connected?
+        @broker = Hutch::Broker.new(config)
+        @broker.connect(options)
+      end
+    end
   end
 
   def self.disconnect

data/lib/yard-settings/yard-settings.rb

@@ -1,2 +1,2 @@
-YARD::Templates::Engine.register_template_path(File.dirname(__FILE__) + '/../../templates')
-require File.join(File.dirname(__FILE__), 'handler') if RUBY19
+YARD::Templates::Engine.register_template_path(File.join(__dir__, '../../templates'))
+require_relative 'handler'

data/spec/hutch/broker_spec.rb

@@ -95,7 +95,7 @@ describe Hutch::Broker do
 
     context 'when configured with a URI' do
       context 'which specifies the port' do
-        before { config[:uri] = 'amqp://guest:guest@127.0.0.1:5672/' }
+        before { config[:uri] = "amqp://#{config[:mq_username]}:#{config[:mq_password]}@#{config[:mq_host]}:#{config[:mq_port]}/" }
 
         it 'successfully connects' do
           c = broker.open_connection
@@ -105,7 +105,7 @@ describe Hutch::Broker do
       end
 
       context 'which does not specify port and uses the amqp scheme' do
-        before { config[:uri] = 'amqp://guest:guest@127.0.0.1/' }
+        before { config[:uri] = "amqp://#{config[:mq_username]}:#{config[:mq_password]}@#{config[:mq_host]}/" }
 
         it 'successfully connects' do
           c = broker.open_connection
@@ -115,11 +115,11 @@ describe Hutch::Broker do
       end
 
       context 'which specifies the amqps scheme' do
-        before { config[:uri] = 'amqps://guest:guest@127.0.0.1/' }
+        before { config[:uri] = "amqps://#{config[:mq_username]}:#{config[:mq_password]}@#{config[:mq_host]}/" }
 
         it 'utilises TLS' do
           expect(Hutch::Adapter).to receive(:new).with(
-            hash_including(tls: true, port: 5671)
+            hash_including(tls: true)
           ).and_return(instance_double('Hutch::Adapter', start: nil))
 
           broker.open_connection
@@ -128,6 +128,76 @@ describe Hutch::Broker do
     end
   end
 
+  describe '#parse_uri' do
+    {
+      "amqp://host/vhost"    => "vhost",
+      "amqp://host/v%2fhost" => "v/host",
+      "amqp://host/%2f"      => "/",
+      "amqp://host/"         => Hutch::Adapter::DEFAULT_VHOST,
+      "amqp://host"          => Hutch::Adapter::DEFAULT_VHOST,
+    }.each do |uri, vhost|
+      it "parses the vhost of #{uri} as #{vhost.inspect}" do
+        config[:uri] = uri
+        broker.send(:parse_uri)
+
+        expect(config[:mq_vhost]).to eq(vhost)
+      end
+    end
+
+    it 'passes the vhost to the connection unchanged' do
+      config[:uri] = "amqp://host/%2f"
+
+      expect(broker.send(:connection_params)[:vhost]).to eq("/")
+    end
+
+    it 'percent-decodes the username and password' do
+      config[:uri] = "amqp://al%23pha:be%20ta@host:10000/vhost"
+      broker.send(:parse_uri)
+
+      expect(config[:mq_username]).to eq("al#pha")
+      expect(config[:mq_password]).to eq("be ta")
+    end
+
+    it 'leaves absent credentials nil' do
+      config[:uri] = "amqp://host:10000/vhost"
+      broker.send(:parse_uri)
+
+      expect(config[:mq_username]).to be_nil
+      expect(config[:mq_password]).to be_nil
+    end
+  end
+
+  describe '#bindings', 'vhost filtering' do
+    let(:api_bindings) do
+      [{ 'source' => 'hutch', 'vhost' => '/', 'destination' => 'q', 'routing_key' => 'key' }]
+    end
+
+    before do
+      config[:mq_exchange] = 'hutch'
+      broker.api_client = double('api_client', bindings: api_bindings)
+    end
+
+    it 'filters on the default vhost when the configured vhost is blank' do
+      config[:mq_vhost] = ''
+
+      expect(broker.bindings).to eq('q' => ['key'])
+    end
+  end
+
+  describe '#sanitized_uri' do
+    it 'percent-encodes the decoded username and vhost again' do
+      config[:uri] = 'amqp://al%23pha:be%20ta@host:10000/v%2Fhost'
+
+      expect(broker.send(:sanitized_uri)).to eq('amqp://al%23pha@host:10000/v%2Fhost')
+    end
+
+    it 'renders the default vhost as a bare trailing slash' do
+      config[:uri] = 'amqp://alpha:beta@host:10000/'
+
+      expect(broker.send(:sanitized_uri)).to eq('amqp://alpha@host:10000/')
+    end
+  end
+
   describe '#open_connection!' do
     it 'sets the #connection to #open_connection' do
       connection = double('connection').as_null_object
@@ -199,6 +269,100 @@ describe Hutch::Broker do
     end
   end
 
+  describe '#replace_channel!', adapter: :bunny do
+    let(:old_channel) { double('Bunny::Channel', open?: true, close: nil) }
+    let(:new_channel) { double('Bunny::Channel').as_null_object }
+    let(:work_pool) { double('Bunny::ConsumerWorkPool', shutdown: nil, join: nil, kill: nil) }
+
+    before do
+      broker.channel = old_channel
+      allow(broker).to receive(:channel_work_pool).and_return(work_pool)
+      allow(broker).to receive(:open_channel).and_return(new_channel)
+      allow(broker).to receive(:declare_exchange!)
+      allow(broker).to receive(:declare_publisher!)
+    end
+
+    it 'drains the work pool before closing the old channel' do
+      expect(work_pool).to receive(:shutdown).ordered
+      expect(work_pool).to receive(:join).with(config[:graceful_exit_timeout]).ordered
+      expect(work_pool).to receive(:kill).ordered
+      expect(old_channel).to receive(:close).ordered
+
+      broker.replace_channel!
+    end
+
+    it 'redeclares the exchange and the publisher on the new channel' do
+      expect(broker).to receive(:declare_exchange!)
+      expect(broker).to receive(:declare_publisher!)
+
+      broker.replace_channel!
+
+      expect(broker.channel).to eq(new_channel)
+    end
+
+    context 'when the old channel is already closed' do
+      let(:old_channel) { double('Bunny::Channel', open?: false) }
+
+      it 'opens a new channel anyway' do
+        expect(old_channel).not_to receive(:close)
+        expect(work_pool).not_to receive(:shutdown)
+
+        broker.replace_channel!
+
+        expect(broker.channel).to eq(new_channel)
+      end
+    end
+
+    context 'when the server closes the old channel concurrently' do
+      it 'opens a new channel anyway' do
+        allow(old_channel).to receive(:close).
+          and_raise(Hutch::Adapter::ChannelAlreadyClosed.new('already closed', old_channel))
+
+        broker.replace_channel!
+
+        expect(broker.channel).to eq(new_channel)
+      end
+    end
+  end
+
+  describe 'acknowledgements' do
+    let(:current_channel) { double('Channel').as_null_object }
+    let(:superseded_channel) { double('Channel') }
+
+    before { broker.channel = current_channel }
+
+    it 'sends them on the channel the delivery arrived on' do
+      expect(current_channel).to receive(:ack).with('dt', false)
+      broker.ack('dt', channel: current_channel)
+
+      expect(current_channel).to receive(:nack).with('dt', false, false)
+      broker.nack('dt', channel: current_channel)
+
+      expect(current_channel).to receive(:reject).with('dt', false)
+      broker.reject('dt', channel: current_channel)
+
+      expect(current_channel).to receive(:reject).with('dt', true)
+      broker.requeue('dt', channel: current_channel)
+    end
+
+    it 'drops them when the channel has been replaced' do
+      expect(superseded_channel).not_to receive(:ack)
+      expect(superseded_channel).not_to receive(:nack)
+      expect(superseded_channel).not_to receive(:reject)
+
+      broker.ack('dt', channel: superseded_channel)
+      broker.nack('dt', channel: superseded_channel)
+      broker.reject('dt', channel: superseded_channel)
+      broker.requeue('dt', channel: superseded_channel)
+    end
+
+    it 'defaults to the current channel' do
+      expect(current_channel).to receive(:ack).with('dt', false)
+
+      broker.ack('dt')
+    end
+  end
+
   describe '#declare_exchange' do
     before do
       broker.open_connection!
@@ -245,9 +409,9 @@ describe Hutch::Broker do
     context 'when given invalid details' do
       before { config[:mq_api_host] = 'notarealhost' }
       after  { broker.disconnect }
-      let(:set_up_api_connection) { ->{ broker.set_up_api_connection } }
+      let(:set_up_api_connection) { broker.set_up_api_connection }
 
-      specify { expect(set_up_api_connection).to raise_error(StandardError) }
+      specify { expect { broker.set_up_api_connection }.to raise_error(StandardError) }
     end
   end
 
@@ -256,13 +420,27 @@ describe Hutch::Broker do
     let(:arguments) { { foo: :bar } }
     before { allow(broker).to receive(:channel) { channel } }
 
-    it 'applies a global namespace' do
-      config[:namespace] = 'mirror-all.service'
-      expect(broker.channel).to receive(:queue) do |*args|
-        args.first == ''
-        args.last == arguments
+    it 'creates a queue with the given name' do
+      expect(broker.channel).to receive(:queue).with('test', arguments: arguments)
+      broker.queue('test'.freeze, arguments: arguments)
+    end
+  end
+
+  describe '#namespaced_queue_name' do
+    context 'with a namespace configured' do
+      before { config[:namespace] = 'mirror-all.service' }
+
+      it 'prepends the namespace' do
+        expect(broker.namespaced_queue_name('test')).to eq('mirror-all.service:test')
+      end
+    end
+
+    context 'without a namespace configured' do
+      before { config[:namespace] = nil }
+
+      it 'returns the name unchanged' do
+        expect(broker.namespaced_queue_name('test')).to eq('test')
       end
-      broker.queue('test', arguments)
     end
   end
 
@@ -279,7 +457,7 @@ describe Hutch::Broker do
 
     context 'with a binding' do
       around do |example|
-        queue = broker.queue('test').bind(broker.exchange, routing_key: 'key')
+        queue = broker.queue('test', durable: true).bind(broker.exchange, routing_key: 'key')
         example.run
         queue.unbind(broker.exchange, routing_key: 'key').delete
       end
@@ -309,7 +487,7 @@ describe Hutch::Broker do
     end
 
     context '(rabbitmq integration test)', rabbitmq: true do
-      let(:queue) { broker.queue('consumer') }
+      let(:queue) { broker.queue('consumer', durable: true) }
       let(:routing_key) { 'key' }
 
       before { allow(broker).to receive(:bindings).and_call_original }

data/spec/hutch/cli_spec.rb

@@ -31,9 +31,10 @@ describe Hutch::CLI do
       end
 
       context "when the config file exists" do
-        let(:file) do
-          Tempfile.new("hutch-test-config.yaml").to_path
-        end
+        # Kept in a let, so the Tempfile is not garbage collected - and with it
+        # unlinked - before the CLI checks that the path exists.
+        let(:config_file) { Tempfile.new("hutch-test-config.yaml") }
+        let(:file) { config_file.to_path }
 
         it "parses the config" do
           expect(Hutch::Config).to receive(:load_from_file)
@@ -55,9 +56,10 @@ describe Hutch::CLI do
       end
 
       context "when the keyfile file exists" do
-        let(:file) do
-          Tempfile.new("hutch-test-key.pem").to_path
-        end
+        # Kept in a let, so the Tempfile is not garbage collected - and with it
+        # unlinked - before the CLI checks that the path exists.
+        let(:key_file) { Tempfile.new("hutch-test-key.pem") }
+        let(:file) { key_file.to_path }
 
         it "sets mq_tls_key to the file" do
           expect(Hutch::Config).to receive(:mq_tls_key=)
@@ -79,9 +81,10 @@ describe Hutch::CLI do
       end
 
       context "when the certfile file exists" do
-        let(:file) do
-          Tempfile.new("hutch-test-cert.pem").to_path
-        end
+        # Kept in a let, so the Tempfile is not garbage collected - and with it
+        # unlinked - before the CLI checks that the path exists.
+        let(:cert_file) { Tempfile.new("hutch-test-cert.pem") }
+        let(:file) { cert_file.to_path }
 
         it "sets mq_tls_cert to the file" do
           expect(Hutch::Config).to receive(:mq_tls_cert=)

data/spec/hutch/config_spec.rb

@@ -31,12 +31,10 @@ describe Hutch::Config do
     end
 
     context 'for invalid attributes' do
-      let(:invalid_get) do
-        -> { Hutch::Config.get(:invalid_attr) }
-      end
+      let(:invalid_get) { Hutch::Config.get(:invalid_attr) }
 
       specify do
-        expect(invalid_get).to raise_error Hutch::UnknownAttributeError
+        expect { invalid_get }.to raise_error Hutch::UnknownAttributeError
       end
     end
   end
@@ -49,15 +47,89 @@ describe Hutch::Config do
       context 'sets value in user config hash' do
         it { is_expected.to eq(new_value) }
       end
+
+      context 'type casting' do
+        context 'number attributes' do
+          before  { Hutch::Config.set(:heartbeat, new_value) }
+          subject(:value) { Hutch::Config.user_config[:heartbeat] }
+
+          let(:new_value) { "0" }
+
+
+          specify 'casts values to integers' do
+            expect(value).to eq 0
+          end
+        end
+      end
+
+      context 'boolean attributes' do
+        context 'from non-empty string' do
+          before  { Hutch::Config.set(:autoload_rails, new_value) }
+          subject(:value) { Hutch::Config.user_config[:autoload_rails] }
+
+          let(:new_value) { "t" }
+
+
+          specify 'casts values to booleans' do
+            expect(value).to eq true
+          end
+        end
+
+        context 'from empty string' do
+          before  { Hutch::Config.set(:autoload_rails, new_value) }
+          subject(:value) { Hutch::Config.user_config[:autoload_rails] }
+
+          let(:new_value) { "" }
+
+
+          specify 'casts values to booleans' do
+            expect(value).to eq false
+          end
+        end
+
+        context 'from boolean' do
+          before  { Hutch::Config.set(:autoload_rails, new_value) }
+          subject(:value) { Hutch::Config.user_config[:autoload_rails] }
+
+          let(:new_value) { true }
+
+
+          specify 'casts values to booleans' do
+            expect(value).to eq true
+          end
+        end
+
+        context 'from nil' do
+          before  { Hutch::Config.set(:autoload_rails, new_value) }
+          subject(:value) { Hutch::Config.user_config[:autoload_rails] }
+
+          let(:new_value) { nil }
+
+
+          specify 'casts values to booleans' do
+            expect(value).to eq false
+          end
+        end
+      end
+
+      context 'string attributes' do
+        before  { Hutch::Config.set(:mq_exchange_type, new_value) }
+        subject(:value) { Hutch::Config.user_config[:mq_exchange_type] }
+
+        let(:new_value) { 1 }
+
+
+        specify 'does not perform any typecasting' do
+          expect(value).to eq new_value
+        end
+      end
     end
 
     context 'for invalid attributes' do
-      let(:invalid_set) do
-        -> { Hutch::Config.set(:invalid_attr, new_value) }
-      end
+      let(:invalid_set) { Hutch::Config.set(:invalid_attr, new_value) }
 
       specify do
-        expect(invalid_set).to raise_error Hutch::UnknownAttributeError
+        expect { invalid_set }.to raise_error Hutch::UnknownAttributeError
       end
     end
   end
@@ -71,8 +143,8 @@ describe Hutch::Config do
     end
 
     context 'for an invalid attribute' do
-      let(:invalid_getter) { -> { Hutch::Config.invalid_attr } }
-      specify { expect(invalid_getter).to raise_error NoMethodError }
+      let(:invalid_getter) { Hutch::Config.invalid_attr }
+      specify { expect { invalid_getter }.to raise_error NoMethodError }
     end
 
     context 'for an ENV-overriden value attribute' do
@@ -109,8 +181,8 @@ describe Hutch::Config do
     end
 
     context 'for an invalid attribute' do
-      let(:invalid_setter) { -> { Hutch::Config.invalid_attr = new_value } }
-      specify { expect(invalid_setter).to raise_error NoMethodError }
+      let(:invalid_setter) { Hutch::Config.invalid_attr = new_value }
+      specify { expect { invalid_setter }.to raise_error NoMethodError }
     end
   end