amqp-client 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cfb2dd354eeb33334cf6848b168f2a0caa486b40cefcce924910a16a77ffa4f
-  data.tar.gz: 7a7896809e27539ab3395b833038c5b328298c9cf6a25aeff7f706e05657e995
+  metadata.gz: c07d38a543ff2c0e6e57dfc4ce4921ba74dbac1091cd55a7d06fc791a4ba501e
+  data.tar.gz: 1909a126c2c6c21d36990cff7b0c623ad4e843afe52ddd5cad69299487286f0c
 SHA512:
-  metadata.gz: c8d0c1797b3b8a81fbe33a154bb255c452f09d925fdeafdfc03fdbb3342b116d7875d6166f7e9b948232f09d69c16179e0270c752b3afdd955d4ad6fca3b6cd1
-  data.tar.gz: 47c518dee777f61435e748045fb7cfebf808ac5ed9cd53813081b222a9abc81b82f85f436482b25dba1dcd10a96c1d1f9bbf4b5266fc90ece48307b61f03ccfb
+  metadata.gz: 6628d1283167e699482baf15ae84bc336c59015b9a86921090ea2a15513267e1fe290788640cef65f92e88f779b039288b05fa6a50d25a449144268edeac7003
+  data.tar.gz: 1684f2e5ef0ffb7c8a67371fe80031904681ccac21e164d190a87605f52b5b73560b4dbd2862f4047f944238f1126aa6de139cdbd1fa1b9acdd39324f8d71c56

data/lib/amqp/client/channel.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "./message"
+require_relative "message"
 require "stringio"
 
 module AMQP
@@ -25,20 +25,25 @@ module AMQP
           @unconfirmed = []
           @unconfirmed_lock = Mutex.new
           @unconfirmed_empty = ConditionVariable.new
+          @nacked = false
           @basic_gets = ::Queue.new
         end
 
         # Override #inspect
         # @api private
         def inspect
-          "#<#{self.class} @id=#{@id} @open=#{@open} @closed=#{@closed} confirm_selected=#{!@confirm.nil?}"\
-            " consumer_count=#{@consumers.size} replies_count=#{@replies.size} unconfirmed_count=#{@unconfirmed.size}>"
+          "#<#{self.class} @id=#{@id} @open=#{@open} @closed=#{@closed} confirm_selected=#{!@confirm.nil?} " \
+            "consumer_count=#{@consumers.size} replies_count=#{@replies.size} unconfirmed_count=#{@unconfirmed.size}>"
         end
 
         # Channel ID
         # @return [Integer]
         attr_reader :id
 
+        # Connection this channel belongs to
+        # @return [Connection]
+        attr_reader :connection
+
         # Open the channel (called from Connection)
         # @return [Channel] self
         # @api private
@@ -51,7 +56,9 @@ module AMQP
           self
         end
 
-        # Gracefully close a connection
+        # Gracefully close channel
+        # @param reason [String] The reason for closing the channel
+        # @param code [Integer] The close code
         # @return [nil]
         def close(reason: "", code: 200)
           return if @closed
@@ -62,7 +69,7 @@ module AMQP
           @replies.close
           @basic_gets.close
           @unconfirmed_lock.synchronize { @unconfirmed_empty.broadcast }
-          @consumers.each_value(&:close)
+          @consumers.each_value { |c| close_consumer(c) }
           nil
         end
 
@@ -75,8 +82,10 @@ module AMQP
           @replies.close
           @basic_gets.close
           @unconfirmed_lock.synchronize { @unconfirmed_empty.broadcast }
-          @consumers.each_value(&:close)
-          @consumers.each_value(&:clear) # empty the queues too, messages can't be acked anymore
+          @consumers.each_value do |c|
+            close_consumer(c)
+            c.msg_q.clear # empty the queues too, messages can't be acked anymore
+          end
           nil
         end
 
@@ -100,7 +109,7 @@ module AMQP
         # @param internal [Boolean] If true the exchange can't be published to directly
         # @param arguments [Hash] Custom arguments
         # @return [nil]
-        def exchange_declare(name, type, passive: false, durable: true, auto_delete: false, internal: false, arguments: {})
+        def exchange_declare(name, type:, passive: false, durable: true, auto_delete: false, internal: false, arguments: {})
           write_bytes FrameBytes.exchange_declare(@id, name, type, passive, durable, auto_delete, internal, arguments)
           expect :exchange_declare_ok
           nil
@@ -118,24 +127,24 @@ module AMQP
         end
 
         # Bind an exchange to another exchange
-        # @param destination [String] Name of the exchange to bind
-        # @param source [String] Name of the exchange to bind to
+        # @param source [String] Name of the source exchange
+        # @param destination [String] Name of the destination exchange
         # @param binding_key [String] Binding key on which messages that match might be routed (depending on exchange type)
         # @param arguments [Hash] Message headers to match on, but only when bound to header exchanges
         # @return [nil]
-        def exchange_bind(destination, source, binding_key, arguments: {})
+        def exchange_bind(source:, destination:, binding_key:, arguments: {})
           write_bytes FrameBytes.exchange_bind(@id, destination, source, binding_key, false, arguments)
           expect :exchange_bind_ok
           nil
         end
 
         # Unbind an exchange from another exchange
-        # @param destination [String] Name of the exchange to unbind
-        # @param source [String] Name of the exchange to unbind from
+        # @param source [String] Name of the source exchange
+        # @param destination [String] Name of the destination exchange
         # @param binding_key [String] Binding key which the queue is bound to the exchange with
         # @param arguments [Hash] Arguments matching the binding that's being removed
         # @return [nil]
-        def exchange_unbind(destination, source, binding_key, arguments: {})
+        def exchange_unbind(source:, destination:, binding_key:, arguments: {})
           write_bytes FrameBytes.exchange_unbind(@id, destination, source, binding_key, false, arguments)
           expect :exchange_unbind_ok
           nil
@@ -151,18 +160,18 @@ module AMQP
         #   @return [Integer] Number of messages in the queue at the time of declaration
         # @!attribute consumer_count
         #   @return [Integer] Number of consumers subscribed to the queue at the time of declaration
-        QueueOk = Struct.new(:queue_name, :message_count, :consumer_count)
+        QueueOk = Data.define(:queue_name, :message_count, :consumer_count)
 
         # Create a queue (operation is idempotent)
         # @param name [String] Name of the queue, can be empty, but will then be generated by the broker
         # @param passive [Boolean] If true an exception will be raised if the queue doesn't already exists
         # @param durable [Boolean] If true the queue will survive broker restarts,
         #   messages in the queue will only survive if they are published as persistent
-        # @param exclusive [Boolean] If true the queue will be deleted when the channel is closed
+        # @param exclusive [Boolean] If true the queue will be deleted when the connection is closed
         # @param auto_delete [Boolean] If true the queue will be deleted when the last consumer stops consuming
         #   (it won't be deleted until at least one consumer has consumed from it)
         # @param arguments [Hash] Custom arguments, such as queue-ttl etc.
-        # @return [QueueOk] The QueueOk struct got `queue_name`, `message_count` and `consumer_count` properties
+        # @return [QueueOk]
         def queue_declare(name = "", passive: false, durable: true, exclusive: false, auto_delete: false, arguments: {})
           durable = false if name.empty?
           exclusive = true if name.empty?
@@ -188,12 +197,12 @@ module AMQP
         end
 
         # Bind a queue to an exchange
-        # @param name [String] Name of the queue to bind
-        # @param exchange [String] Name of the exchange to bind to
+        # @param name [String] Name of the queue
+        # @param exchange [String] Name of the exchange
         # @param binding_key [String] Binding key on which messages that match might be routed (depending on exchange type)
         # @param arguments [Hash] Message headers to match on, but only when bound to header exchanges
         # @return [nil]
-        def queue_bind(name, exchange, binding_key, arguments: {})
+        def queue_bind(name, exchange:, binding_key: "", arguments: {})
           write_bytes FrameBytes.queue_bind(@id, name, exchange, binding_key, false, arguments)
           expect :queue_bind_ok
           nil
@@ -211,12 +220,12 @@ module AMQP
         end
 
         # Unbind a queue from an exchange
-        # @param name [String] Name of the queue to unbind
-        # @param exchange [String] Name of the exchange to unbind from
+        # @param name [String] Name of the queue
+        # @param exchange [String] Name of the exchange
         # @param binding_key [String] Binding key which the queue is bound to the exchange with
         # @param arguments [Hash] Arguments matching the binding that's being removed
         # @return [nil]
-        def queue_unbind(name, exchange, binding_key, arguments: {})
+        def queue_unbind(name, exchange:, binding_key: "", arguments: {})
           write_bytes FrameBytes.queue_unbind(@id, name, exchange, binding_key, arguments)
           expect :queue_unbind_ok
           nil
@@ -240,7 +249,7 @@ module AMQP
         end
 
         # Publishes a message to an exchange
-        # @param body [String] The body, can be a string or a byte array
+        # @param body [String] The body
         # @param exchange [String] Name of the exchange to publish to
         # @param routing_key [String] The routing key that the exchange might use to route the message to a queue
         # @param properties [Properties]
@@ -260,7 +269,7 @@ module AMQP
         # @option properties [String] user_id Can be used to verify that this is the user that published the message
         # @option properties [String] app_id Can be used to indicates which app that generated the message
         # @return [nil]
-        def basic_publish(body, exchange, routing_key, **properties)
+        def basic_publish(body, exchange:, routing_key: "", **properties)
           body_max = @connection.frame_max - 8
           id = @id
           mandatory = properties.delete(:mandatory) || false
@@ -297,50 +306,90 @@ module AMQP
         # @option (see #basic_publish)
         # @return [Boolean] True if the message was successfully published
         # @raise (see #basic_publish)
-        def basic_publish_confirm(body, exchange, routing_key, **properties)
+        def basic_publish_confirm(body, exchange:, routing_key: "", **properties)
           confirm_select(no_wait: true)
-          basic_publish(body, exchange, routing_key, **properties)
+          basic_publish(body, exchange:, routing_key:, **properties)
           wait_for_confirms
         end
 
+        # Response when subscribing (starting a consumer)
+        # @!attribute channel_id
+        #   @return [Integer] The channel ID
+        # @!attribute consumer_tag
+        #   @return [String] The consumer tag
+        # @!attribute worker_threads
+        #   @return [Array<Thread>] Array of worker threads
+        ConsumeOk = Data.define(:channel_id, :consumer_tag, :worker_threads, :msg_q, :on_cancel)
+
         # Consume messages from a queue
         # @param queue [String] Name of the queue to subscribe to
         # @param tag [String] Custom consumer tag, will be auto assigned by the broker if empty.
-        #   Has to be uniqe among this channel's consumers only
+        #   Has to be unique among this channel's consumers only
         # @param no_ack [Boolean] When false messages have to be manually acknowledged (or rejected)
         # @param exclusive [Boolean] When true only a single consumer can consume from the queue at a time
         # @param arguments [Hash] Custom arguments for the consumer
         # @param worker_threads [Integer] Number of threads processing messages,
         #   0 means that the thread calling this method will process the messages and thus this method will block
+        # @param on_cancel [Proc] Optional proc that will be called if the consumer is cancelled by the broker
+        #   The proc will be called with the consumer tag as the only argument
         # @yield [Message] Delivered message from the queue
-        # @return [Array<(String, Array<Thread>)>] Returns consumer_tag and an array of worker threads
+        # @return [ConsumeOk]
         # @return [nil] When `worker_threads` is 0 the method will return when the consumer is cancelled
-        def basic_consume(queue, tag: "", no_ack: true, exclusive: false, arguments: {}, worker_threads: 1, &blk)
-          write_bytes FrameBytes.basic_consume(@id, queue, tag, no_ack, exclusive, arguments)
-          tag, = expect(:basic_consume_ok)
-          @consumers[tag] = q = ::Queue.new
+        def basic_consume(queue, tag: "", no_ack: true, exclusive: false, no_wait: false,
+                          arguments: {}, worker_threads: 1, on_cancel: nil, &blk)
+          raise ArgumentError, "consumer_tag required when no_wait" if no_wait && tag.empty?
+
+          write_bytes FrameBytes.basic_consume(@id, queue, tag, no_ack, exclusive, no_wait, arguments)
+          consumer_tag, = expect(:basic_consume_ok) unless no_wait
+          msg_q = ::Queue.new
           if worker_threads.zero?
-            consume_loop(q, tag, &blk)
+            @consumers[consumer_tag] =
+              ConsumeOk.new(channel_id: @id, consumer_tag:, worker_threads: [], msg_q:, on_cancel:)
+            consume_loop(msg_q, consumer_tag, &blk)
             nil
           else
             threads = Array.new(worker_threads) do
-              Thread.new { consume_loop(q, tag, &blk) }
+              Thread.new { consume_loop(msg_q, consumer_tag, &blk) }
             end
-            [tag, threads]
+            @consumers[consumer_tag] =
+              ConsumeOk.new(channel_id: @id, consumer_tag:, worker_threads: threads, msg_q:, on_cancel:)
           end
         end
 
+        # Consume a single message from a queue
+        # @param queue [String] Name of the queue to subscribe to
+        # @param timeout [Numeric, nil] Number of seconds to wait for a message
+        # @yield [] Block in which the message will be yielded
+        # @return [Message] The single message received from the queue
+        # @raise [Timeout::Error] if no response is received within the timeout period
+        def basic_consume_once(queue, timeout: nil, &)
+          tag = "consume-once-#{rand(1024)}"
+          write_bytes FrameBytes.basic_consume(@id, queue, tag, true, false, true, nil)
+          msg_q = ::Queue.new
+          @consumers[tag] =
+            ConsumeOk.new(channel_id: @id, consumer_tag: tag, worker_threads: [], msg_q:, on_cancel: nil)
+          yield if block_given?
+          msg = msg_q.pop(timeout:)
+          write_bytes FrameBytes.basic_cancel(@id, tag, no_wait: true)
+          consumer = @consumers.delete(tag)
+          close_consumer(consumer)
+          raise Timeout::Error, "No message received in #{timeout} seconds" if timeout && msg.nil?
+
+          msg
+        end
+
         # Cancel/abort/stop a consumer
         # @param consumer_tag [String] Tag of the consumer to cancel
         # @param no_wait [Boolean] Will wait for a confirmation from the broker that the consumer is cancelled
         # @return [nil]
         def basic_cancel(consumer_tag, no_wait: false)
-          consumer = @consumers.fetch(consumer_tag)
-          return if consumer.closed?
+          consumer = @consumers[consumer_tag]
+          return unless consumer
 
           write_bytes FrameBytes.basic_cancel(@id, consumer_tag)
           expect(:basic_cancel_ok) unless no_wait
-          consumer.close
+          @consumers.delete(consumer_tag)
+          close_consumer(consumer)
           nil
         end
 
@@ -357,6 +406,7 @@ module AMQP
 
         # Acknowledge a message
         # @param delivery_tag [Integer] The delivery tag of the message to acknowledge
+        # @param multiple [Boolean] Ack all messages up to this message
         # @return [nil]
         def basic_ack(delivery_tag, multiple: false)
           write_bytes FrameBytes.basic_ack(@id, delivery_tag, multiple)
@@ -387,7 +437,7 @@ module AMQP
         #   if true to any consumer
         # @return [nil]
         def basic_recover(requeue: false)
-          write_bytes FrameBytes.basic_recover(@id, requeue: requeue)
+          write_bytes FrameBytes.basic_recover(@id, requeue:)
           expect :basic_recover_ok
           nil
         end
@@ -413,20 +463,23 @@ module AMQP
         end
 
         # Block until all publishes messages are confirmed
-        # @return nil
+        # @return [Boolean] True if all messages were acked, false if any were nacked
         def wait_for_confirms
           @unconfirmed_lock.synchronize do
             until @unconfirmed.empty?
               @unconfirmed_empty.wait(@unconfirmed_lock)
               raise Error::Closed.new(@id, *@closed) if @closed
             end
+            result = !@nacked
+            @nacked = false # Reset for next round of publishes
+            result
           end
         end
 
         # Called by Connection when received ack/nack from broker
         # @api private
         def confirm(args)
-          _ack_or_nack, delivery_tag, multiple = *args
+          ack_or_nack, delivery_tag, multiple = *args
           @unconfirmed_lock.synchronize do
             case multiple
             when true
@@ -435,6 +488,7 @@ module AMQP
             when false
               @unconfirmed.delete(delivery_tag) || raise("Delivery tag not found")
             end
+            @nacked = true if ack_or_nack == :nack
             @unconfirmed_empty.broadcast if @unconfirmed.empty?
           end
         end
@@ -508,14 +562,29 @@ module AMQP
           next_message_finished!
         end
 
+        # Handle consumer cancellation from the broker
         # @api private
-        def close_consumer(tag)
-          @consumers.fetch(tag).close
+        def cancel_consumer(tag)
+          consumer = @consumers.delete(tag)
+          return unless consumer
+
+          close_consumer(consumer)
+          begin
+            consumer.on_cancel&.call(consumer.consumer_tag)
+          rescue StandardError => e
+            warn "AMQP-Client consumer on_cancel callback error: #{e.class}: #{e.message}"
+          end
           nil
         end
 
         private
 
+        def close_consumer(consumer)
+          consumer.msg_q.close
+          # The worker threads will exit when the queue is closed
+          nil
+        end
+
         def next_message_finished!
           next_msg = @next_msg
           if next_msg.is_a? ReturnMessage
@@ -528,7 +597,7 @@ module AMQP
             @basic_gets.push next_msg
           else
             Thread.pass until (consumer = @consumers[next_msg.consumer_tag])
-            consumer.push next_msg
+            consumer.msg_q.push next_msg
           end
           nil
         ensure
@@ -544,7 +613,7 @@ module AMQP
         def expect(expected_frame_type)
           frame_type, *args = @replies.pop
           raise Error::Closed.new(@id, *@closed) if frame_type.nil?
-          raise Error::UnexpectedFrame.new(expected_frame_type, frame_type) unless frame_type == expected_frame_type
+          raise Error::UnexpectedFrameType.new(expected_frame_type, frame_type) unless frame_type == expected_frame_type
 
           args
         end

data/lib/amqp/client/configuration.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module AMQP
+  class Client
+    # Configuration for AMQP::Client
+    # @!attribute strict_coding
+    #   @return [Boolean] Whether to raise on unknown codecs
+    # @!attribute default_content_type
+    #   @return [String, nil] Default content type for published messages
+    # @!attribute default_content_encoding
+    #   @return [String, nil] Default content encoding for published messages
+    class Configuration
+      attr_accessor :strict_coding, :default_content_type, :default_content_encoding
+      attr_reader :codec_registry
+
+      # Initialize a new configuration
+      # @param codec_registry [MessageCodecRegistry] The codec registry to use
+      def initialize(codec_registry)
+        @codec_registry = codec_registry
+        @strict_coding = false
+        @default_content_type = nil
+        @default_content_encoding = nil
+      end
+
+      # Enable all built-in codecs (parsers and coders) for automatic message encoding/decoding
+      # This is a convenience method that delegates to the codec registry
+      # @return [self]
+      def enable_builtin_codecs
+        codec_registry.enable_builtin_codecs
+        self
+      end
+
+      # Enable built-in parsers for common content types
+      # @return [self]
+      def enable_builtin_parsers
+        codec_registry.enable_builtin_parsers
+        self
+      end
+
+      # Enable built-in coders for common content encodings
+      # @return [self]
+      def enable_builtin_coders
+        codec_registry.enable_builtin_coders
+        self
+      end
+
+      # Register a custom parser for a content type
+      # @param content_type [String] The content_type to match
+      # @param parser [Object] The parser object
+      # @return [self]
+      def register_parser(content_type:, parser:)
+        codec_registry.register_parser(content_type:, parser:)
+        self
+      end
+
+      # Register a custom coder for a content encoding
+      # @param content_encoding [String] The content_encoding to match
+      # @param coder [Object] The coder object
+      # @return [self]
+      def register_coder(content_encoding:, coder:)
+        codec_registry.register_coder(content_encoding:, coder:)
+        self
+      end
+    end
+  end
+end

data/lib/amqp/client/connection.rb

@@ -3,9 +3,9 @@
 require "socket"
 require "uri"
 require "openssl"
-require_relative "./frame_bytes"
-require_relative "./channel"
-require_relative "./errors"
+require_relative "frame_bytes"
+require_relative "channel"
+require_relative "errors"
 
 module AMQP
   class Client
@@ -15,6 +15,8 @@ module AMQP
       # @param uri [String] URL on the format amqp://username:password@hostname/vhost, use amqps:// for encrypted connection
       # @param read_loop_thread [Boolean] If true run {#read_loop} in a background thread,
       #   otherwise the user have to run it explicitly, without {#read_loop} the connection won't function
+      # @param codec_registry [MessageCodecRegistry] Registry for message codecs
+      # @param strict_coding [Boolean] Whether to raise errors on unsupported codecs
       # @option options [Boolean] connection_name (PROGRAM_NAME) Set a name for the connection to be able to identify
       #   the client from the broker
       # @option options [Boolean] verify_peer (true) Verify broker's TLS certificate, set to false for self-signed certs
@@ -26,7 +28,7 @@ module AMQP
       #   Maxium allowed is 65_536.  The smallest of the client's and the broker's value will be used.
       # @option options [String] keepalive (60:10:3) TCP keepalive setting, 60s idle, 10s interval between probes, 3 probes
       # @return [Connection]
-      def initialize(uri = "", read_loop_thread: true, **options)
+      def initialize(uri = "", read_loop_thread: true, codec_registry: nil, strict_coding: false, **options)
         uri = URI.parse(uri)
         tls = uri.scheme == "amqps"
         port = port_from_env || uri.port || (tls ? 5671 : 5672)
@@ -43,6 +45,8 @@ module AMQP
         @channel_max = channel_max.zero? ? 65_536 : channel_max
         @frame_max = frame_max
         @heartbeat = heartbeat
+        @codec_registry = codec_registry
+        @strict_coding = strict_coding
         @channels = {}
         @channels_lock = Mutex.new
         @closed = nil
@@ -71,14 +75,22 @@ module AMQP
       # Alias for {#initialize}
       # @see #initialize
       # @deprecated
-      def self.connect(uri, read_loop_thread: true, **options)
-        new(uri, read_loop_thread: read_loop_thread, **options)
+      def self.connect(uri, read_loop_thread: true, **)
+        new(uri, read_loop_thread:, **)
       end
 
       # The max frame size negotiated between the client and the broker
       # @return [Integer]
       attr_reader :frame_max
 
+      # The codec registry for message encoding/decoding
+      # @return [MessageCodecRegistry, nil]
+      attr_reader :codec_registry
+
+      # Whether to use strict coding (raise errors on unsupported codecs)
+      # @return [Boolean]
+      attr_reader :strict_coding
+
       # Custom inspect
       # @return [String]
       # @api private
@@ -91,6 +103,7 @@ module AMQP
       # @return [Channel]
       def channel(id = nil)
         raise ArgumentError, "Channel ID cannot be 0" if id&.zero?
+
         raise ArgumentError, "Channel ID higher than connection's channel max #{@channel_max}" if id && id > @channel_max
 
         ch = @channels_lock.synchronize do
@@ -142,7 +155,7 @@ module AMQP
       # @param secret [String] The new secret
       # @param reason [String] A reason to update it
       # @return [nil]
-      def update_secret(secret, reason)
+      def update_secret(secret, reason:)
         write_bytes FrameBytes.update_secret(secret, reason)
         expect(:update_secret_ok)
         nil
@@ -202,14 +215,15 @@ module AMQP
         loop do
           socket.read(7, frame_start) || raise(IOError)
           type, channel_id, frame_size = frame_start.unpack("C S> L>")
-          frame_max >= frame_size || raise(Error, "Frame size #{frame_size} larger than negotiated max frame size #{frame_max}")
+          frame_max >= frame_size ||
+            raise(Error, "Frame size #{frame_size} larger than negotiated max frame size #{frame_max}")
 
           # read the frame content
           socket.read(frame_size, frame_buffer) || raise(IOError)
 
           # make sure that the frame end is correct
           frame_end = socket.readchar.ord
-          raise Error::UnexpectedFrameEnd, frame_end if frame_end != 206
+          raise Error::UnexpectedFrameTypeEnd, frame_end if frame_end != 206
 
           # parse the frame, will return false if a close frame was received
           parse_frame(type, channel_id, frame_buffer) || return
@@ -285,9 +299,11 @@ module AMQP
               reply_code, reply_text_len = buf.unpack("@4 S> C")
               reply_text = buf.byteslice(7, reply_text_len).force_encoding("utf-8")
               classid, methodid = buf.byteslice(7 + reply_text_len, 4).unpack("S> S>")
-              channel = @channels_lock.synchronize { @channels.delete(channel_id) }
-              channel.closed!(:channel, reply_code, reply_text, classid, methodid)
-              write_bytes FrameBytes.channel_close_ok(channel_id)
+              @channels_lock.synchronize do
+                channel = @channels.delete(channel_id)
+                channel.closed!(:channel, reply_code, reply_text, classid, methodid)
+                write_bytes FrameBytes.channel_close_ok(channel_id)
+              end
             when 41 # channel#close-ok
               channel = @channels_lock.synchronize { @channels.delete(channel_id) }
               channel.reply [:channel_close_ok]
@@ -336,7 +352,7 @@ module AMQP
               tag_len = buf.getbyte(4)
               tag = buf.byteslice(5, tag_len).force_encoding("utf-8")
               no_wait = buf.getbyte(5 + tag_len) == 1
-              channel.close_consumer(tag)
+              channel.cancel_consumer(tag)
               write_bytes FrameBytes.basic_cancel_ok(@id, tag) unless no_wait
             when 31 # cancel-ok
               tag_len = buf.getbyte(4)
@@ -470,7 +486,7 @@ module AMQP
 
           raise Error, "Connection closed while waiting for #{expected_frame_type}"
         end
-        frame_type == expected_frame_type || raise(Error::UnexpectedFrame.new(expected_frame_type, frame_type))
+        frame_type == expected_frame_type || raise(Error::UnexpectedFrameType.new(expected_frame_type, frame_type))
         args
       end
 
@@ -479,7 +495,8 @@ module AMQP
       # @return [OpenSSL::SSL::SSLSocket]
       def open_socket(host, port, tls, options)
         connect_timeout = options.fetch(:connect_timeout, 30).to_f
-        socket = Socket.tcp host, port, connect_timeout: connect_timeout
+        socket = Socket.tcp(host, port, connect_timeout:)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
         keepalive = options.fetch(:keepalive, "").split(":", 3).map!(&:to_i)
         enable_tcp_keepalive(socket, *keepalive)
         if tls
@@ -515,7 +532,7 @@ module AMQP
 
           type, channel_id, frame_size = buf.unpack("C S> L>")
           frame_end = buf.getbyte(frame_size + 7)
-          raise Error::UnexpectedFrameEnd, frame_end if frame_end != 206
+          raise Error::UnexpectedFrameTypeEnd, frame_end if frame_end != 206
 
           case type
           when 1 # method frame
@@ -558,7 +575,7 @@ module AMQP
         rescue *READ_EXCEPTIONS
           nil
         end
-        raise e
+        raise Error, "Could not establish AMQP connection: invalid handshake (#{e.message})"
       end
 
       # Enable TCP keepalive, which is preferred to heartbeats
@@ -583,7 +600,7 @@ module AMQP
       # @return [Integer] A port number
       # @return [nil] When the environment variable AMQP_PORT isn't set
       def port_from_env
-        return unless (port = ENV["AMQP_PORT"])
+        return unless (port = ENV.fetch("AMQP_PORT", nil))
 
         port.to_i
       end

data/lib/amqp/client/consumer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module AMQP
+  class Client
+    # Consumer abstraction
+    class Consumer
+      attr_reader :queue, :id, :channel_id, :prefetch, :block, :basic_consume_args
+
+      # @api private
+      def initialize(client:, channel_id:, id:, block:, **settings)
+        @client = client
+        @channel_id = channel_id
+        @id = id
+        @queue = settings.fetch(:queue)
+        @basic_consume_args = settings.fetch(:basic_consume_args)
+        @prefetch = settings.fetch(:prefetch)
+        @consume_ok = settings.fetch(:consume_ok)
+        @block = block
+      end
+
+      # Cancel the consumer
+      # @return [self]
+      def cancel
+        @client.cancel_consumer(self)
+        self
+      end
+
+      # True if the consumer is cancelled/closed
+      # @return [Boolean]
+      def closed?
+        @consume_ok.msg_q.closed?
+      end
+
+      # Return the consumer tag
+      # @return [String]
+      def tag
+        @consume_ok.consumer_tag
+      end
+
+      # Update the consumer with new metadata after reconnection
+      # @api private
+      def update_consume_ok(consume_ok)
+        @consume_ok = consume_ok
+      end
+    end
+  end
+end