amqp-client 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d7dae171425db13570982c850a9efaeca9bc848be72b0a7e8652bef0407181d
-  data.tar.gz: e8e263b52a8055cb4385b980727c7ef5e35af5bbf127ac270474145ac77ebfc2
+  metadata.gz: 5e6dd3fef130c286e97eadd9bb6d3d4de0fa67599361604cec3560879b9b4bdf
+  data.tar.gz: c2ce00f897c68d3085427854b08cc98d3487b40bb5327ce38bb216c98357e366
 SHA512:
-  metadata.gz: eb41014541c095620671d2a19564051eb65bcbf296e3f7464b4542f4a22ff74867b0466063eed15442f26d3acbec1de81c498cf94cb77adce612fe413389523c
-  data.tar.gz: c7620262a2de427abb0efb06b253e065f3aa41e4a59feee4336045650afc2c8ac389a8ce784631b17e8f8a9d95be426eb370b7573f068c9848dd5130baeb0564
+  metadata.gz: 9b62e8ee74ec542be5617b08fbd0e36e5fc16294f99cd0ec61781c7c7425005c426e8358a74abf45a1a24ecb88451b94ef50ee7524403ac7097748b2e94b55b5
+  data.tar.gz: 5c3e63369578923e20b441fbe9728b374e18150c75ed155291b802c42f80f668b704b39e80b144b90346a8d769d9b71f031b9fca712e6ac52c100a88e46380e3

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 ## [Unreleased]
 
+## [1.0.0] - 2021-08-27
+
+- Verify TLS certificate matches hostname
+- TLS thread-safety
+- Assemble Messages in the (single threaded) read_loop thread
+- Give read_loop_thread higher priority so that channel errors crop up faster
+- One less Thread required per Consumer
+- Read exactly one frame at a time, not trying to split/assemble frames over socket reads
+- Heafty speedup for message assembling with StringIO
+- Channel#queue_declare returns a struct for nicer API (still backward compatible)
+- AMQP::Client#publish_and_forget for fast, non confirmed publishes
+- Allow Properties#timestamp to be an integer (in addition to Time)
+- Bug fix allow Properties#expiration to be an Integer
+- Consistent use of named parameters
+- High level Exchange API
+- Don't try to reconnect if first connect fails
+- Bug fix: Close all channels when connection is closed by server
+- Raise error if run out of channels
+- Improved retry in high level client
+- Bug fix: Support channel_max 0
+
+## [0.3.0] - 2021-08-20
+
+- Channel#wait_for_confirms is a smarter way of waiting for publish confirms
+- Default connection_name to $PROGRAM_NAME
+
+## [0.2.3] - 2021-08-19
+
+- Improved TLS/AMQPS support
+
+## [0.2.2] - 2021-08-19
+
+- TLS port issue fixed
 
 ## [0.2.1] - 2021-08-19
 

data/README.md

@@ -1,6 +1,6 @@
 # AMQP::Client
 
-An AMQP 0-9-1 client alternative, trying to keep things as simple as possible.
+An AMQP 0-9-1 Ruby client, trying to keep things as simple as possible.
 
 ## Installation
 
@@ -34,7 +34,7 @@ msg = ch.basic_get q[:queue_name]
 puts msg.body
 ```
 
-High level API, is an easier and safer API, that only deal with durable queues and persisted messages. All methods are blocking in the case of connection loss etc. It's also fully thread-safe. Don't expect it to be extreme throughput, be expect 100% delivery guarantees (messages might be deliviered twice, in the unlikely event of a connection loss between message publish and message confirmed by the server).
+High level API, is an easier and safer API, that only deal with durable queues and persisted messages. All methods are blocking in the case of connection loss etc. It's also fully thread-safe. Don't expect it to have extreme throughput, but expect 100% delivery guarantees (messages might be delivered twice, in the unlikely event of connection loss between message publish and message confirmation by the server).
 
 ```ruby
 amqp = AMQP::Client.new("amqp://localhost")
@@ -46,8 +46,8 @@ q = amqp.queue("myqueue")
 # Bind the queue to any exchange, with any binding key
 q.bind("amq.topic", "my.events.*")
 
-# The message will be reprocessed if the client lost connection to the server
-# between the message arrived and the message was supposed to be ack:ed.
+# The message will be reprocessed if the client loses connection to the server
+# between message arrival and when the message was supposed to be ack'ed.
 q.subscribe(prefetch: 20) do |msg|
   process(JSON.parse(msg.body))
   msg.ack

data/lib/amqp/client/channel.rb

@@ -6,25 +6,32 @@ module AMQP
   # AMQP Channel
   class Channel
     def initialize(connection, id)
-      @replies = ::Queue.new
       @connection = connection
       @id = id
+      @replies = ::Queue.new
       @consumers = {}
-      @confirm = nil
-      @last_confirmed = 0
       @closed = nil
-      @on_return = nil
       @open = false
+      @on_return = nil
+      @confirm = nil
+      @unconfirmed = ::Queue.new
+      @unconfirmed_empty = ::Queue.new
+      @basic_gets = ::Queue.new
     end
 
-    attr_reader :id, :consumers
+    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}>"
+    end
+
+    attr_reader :id
 
     def open
       return self if @open
 
+      @open = true
       write_bytes FrameBytes.channel_open(@id)
       expect(:channel_open_ok)
-      @open = true
       self
     end
 
@@ -32,21 +39,25 @@ module AMQP
       return if @closed
 
       write_bytes FrameBytes.channel_close(@id, reason, code)
-      expect :channel_close_ok
       @closed = [code, reason]
+      expect :channel_close_ok
+      @replies.close
+      @basic_gets.close
+      @unconfirmed_empty.close
+      @consumers.each_value(&:close)
     end
 
-    # Called when closed by server
+    # Called when channel is closed by server
     def closed!(code, reason, classid, methodid)
-      write_bytes FrameBytes.channel_close_ok(@id)
       @closed = [code, reason, classid, methodid]
       @replies.close
-      @consumers.each { |_, q| q.close }
-      @consumers.clear
+      @basic_gets.close
+      @unconfirmed_empty.close
+      @consumers.each_value(&:close)
     end
 
-    def exchange_declare(name, type, passive: false, durable: true, auto_delete: false, internal: false, **args)
-      write_bytes FrameBytes.exchange_declare(@id, name, type, passive, durable, auto_delete, internal, args)
+    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
     end
 
@@ -55,16 +66,18 @@ module AMQP
       expect :exchange_delete_ok
     end
 
-    def exchange_bind(destination, source, binding_key, arguments = {})
+    def exchange_bind(destination, source, binding_key, arguments: {})
       write_bytes FrameBytes.exchange_bind(@id, destination, source, binding_key, false, arguments)
       expect :exchange_bind_ok
     end
 
-    def exchange_unbind(destination, source, binding_key, arguments = {})
+    def exchange_unbind(destination, source, binding_key, arguments: {})
       write_bytes FrameBytes.exchange_unbind(@id, destination, source, binding_key, false, arguments)
       expect :exchange_unbind_ok
     end
 
+    QueueOk = Struct.new(:queue_name, :message_count, :consumer_count)
+
     def queue_declare(name = "", passive: false, durable: true, exclusive: false, auto_delete: false, arguments: {})
       durable = false if name.empty?
       exclusive = true if name.empty?
@@ -72,11 +85,8 @@ module AMQP
 
       write_bytes FrameBytes.queue_declare(@id, name, passive, durable, exclusive, auto_delete, arguments)
       name, message_count, consumer_count = expect(:queue_declare_ok)
-      {
-        queue_name: name,
-        message_count: message_count,
-        consumer_count: consumer_count
-      }
+
+      QueueOk.new(name, message_count, consumer_count)
     end
 
     def queue_delete(name, if_unused: false, if_empty: false, no_wait: false)
@@ -85,7 +95,7 @@ module AMQP
       message_count
     end
 
-    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
     end
@@ -95,44 +105,38 @@ module AMQP
       expect :queue_purge_ok unless no_wait
     end
 
-    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
     end
 
     def basic_get(queue_name, no_ack: true)
       write_bytes FrameBytes.basic_get(@id, queue_name, no_ack)
-      frame, *rest = @replies.shift
-      case frame
-      when :basic_get_ok
-        delivery_tag, exchange_name, routing_key, _message_count, redelivered = rest
-        body_size, properties = expect(:header)
-        pos = 0
-        body = String.new("", capacity: body_size)
-        while pos < body_size
-          body_part, = expect(:body)
-          body += body_part
-          pos += body_part.bytesize
-        end
-        Message.new(self, delivery_tag, exchange_name, routing_key, properties, body, redelivered)
+      case (msg = @basic_gets.pop)
+      when Message then msg
       when :basic_get_empty then nil
       when nil              then raise AMQP::Client::ChannelClosedError.new(@id, *@closed)
-      else raise AMQP::Client::UnexpectedFrame.new(%i[basic_get_ok basic_get_empty], frame)
       end
     end
 
     def basic_publish(body, exchange, routing_key, **properties)
       frame_max = @connection.frame_max - 8
       id = @id
+      mandatory = properties.delete(:mandatory) || false
+      case properties.delete(:persistent)
+      when true then properties[:delivery_mode] = 2
+      when false then properties[:delivery_mode] = 1
+      end
 
-      if 0 < body.bytesize && body.bytesize <= frame_max
-        write_bytes FrameBytes.basic_publish(id, exchange, routing_key, properties.delete(:mandatory) || false),
+      if body.bytesize.between?(1, frame_max)
+        write_bytes FrameBytes.basic_publish(id, exchange, routing_key, mandatory),
                     FrameBytes.header(id, body.bytesize, properties),
                     FrameBytes.body(id, body)
-        return @confirm ? @confirm += 1 : nil
+        @unconfirmed.push @confirm += 1 if @confirm
+        return
       end
 
-      write_bytes FrameBytes.basic_publish(id, exchange, routing_key, properties.delete(:mandatory) || false),
+      write_bytes FrameBytes.basic_publish(id, exchange, routing_key, mandatory),
                   FrameBytes.header(id, body.bytesize, properties)
       pos = 0
       while pos < body.bytesize # split body into multiple frame_max frames
@@ -141,33 +145,31 @@ module AMQP
         write_bytes FrameBytes.body(id, body_part)
         pos += len
       end
-      @confirm += 1 if @confirm
+      @unconfirmed.push @confirm += 1 if @confirm
+      nil
     end
 
     def basic_publish_confirm(body, exchange, routing_key, **properties)
       confirm_select(no_wait: true)
-      id = basic_publish(body, exchange, routing_key, **properties)
-      wait_for_confirm(id)
+      basic_publish(body, exchange, routing_key, **properties)
+      wait_for_confirms
     end
 
     # Consume from a queue
     # worker_threads: 0 => blocking, messages are executed in the thread calling this method
-    def basic_consume(queue, tag: "", no_ack: true, exclusive: false, arguments: {},
-                      worker_threads: 1)
+    def basic_consume(queue, tag: "", no_ack: true, exclusive: false, arguments: {}, worker_threads: 1)
       write_bytes FrameBytes.basic_consume(@id, queue, tag, no_ack, exclusive, arguments)
       tag, = expect(:basic_consume_ok)
       q = @consumers[tag] = ::Queue.new
-      msgs = ::Queue.new
-      Thread.new { recv_deliveries(tag, q, msgs) }
       if worker_threads.zero?
-        while (msg = msgs.shift)
-          yield msg
+        loop do
+          yield (q.pop || break)
         end
       else
         threads = Array.new(worker_threads) do
           Thread.new do
-            while (msg = msgs.shift)
-              yield(msg)
+            loop do
+              yield (q.pop || break)
             end
           end
         end
@@ -211,20 +213,37 @@ module AMQP
 
       write_bytes FrameBytes.confirm_select(@id, no_wait)
       expect :confirm_select_ok unless no_wait
-      @confirms = ::Queue.new
       @confirm = 0
     end
 
-    def wait_for_confirm(id)
-      raise ArgumentError, "Confirm id has to a positive number" unless id&.positive?
-      return true if @last_confirmed >= id
+    # Block until all publishes messages are confirmed
+    def wait_for_confirms
+      return true if @unconfirmed.empty?
+
+      case @unconfirmed_empty.pop
+      when true then true
+      when false then false
+      else raise AMQP::Client::ChannelClosedError.new(@id, *@closed)
+      end
+    end
 
+    # Called by Connection when received ack/nack from server
+    def confirm(args)
+      ack_or_nack, delivery_tag, multiple = *args
       loop do
-        ack, delivery_tag, multiple = @confirms.shift || break
-        @last_confirmed = delivery_tag
-        return ack if delivery_tag == id || (delivery_tag > id && multiple)
+        tag = @unconfirmed.pop(true)
+        break if tag == delivery_tag
+        next if multiple && tag < delivery_tag
+
+        @unconfirmed << tag # requeue
+      rescue ThreadError
+        break
+      end
+      return unless @unconfirmed.empty?
+
+      @unconfirmed_empty.num_waiting.times do
+        @unconfirmed_empty << (ack_or_nack == :ack)
       end
-      false
     end
 
     def tx_select
@@ -242,51 +261,66 @@ module AMQP
       expect :tx_rollback_ok
     end
 
+    def on_return(&block)
+      @on_return = block
+    end
+
     def reply(args)
       @replies.push(args)
     end
 
-    def confirm(args)
-      @confirms.push(args)
+    def message_returned(reply_code, reply_text, exchange, routing_key)
+      @next_msg = ReturnMessage.new(reply_code, reply_text, exchange, routing_key, nil, "")
     end
 
-    def message_returned(reply_code, reply_text, exchange, routing_key)
-      Thread.new do
-        body_size, properties = expect(:header)
-        body = String.new("", capacity: body_size)
-        while body.bytesize < body_size
-          body_part, = expect(:body)
-          body += body_part
-        end
-        msg = ReturnMessage.new(reply_code, reply_text, exchange, routing_key, properties, body)
+    def message_delivered(consumer_tag, delivery_tag, redelivered, exchange, routing_key)
+      @next_msg = Message.new(self, delivery_tag, exchange, routing_key, nil, "", redelivered, consumer_tag)
+    end
 
-        if @on_return
-          @on_return.call(msg)
-        else
-          puts "[WARN] Message returned: #{msg.inspect}"
-        end
+    def basic_get_empty
+      @basic_gets.push :basic_get_empty
+    end
+
+    def header_delivered(body_size, properties)
+      @next_msg.properties = properties
+      if body_size.zero?
+        next_message_finished!
+      else
+        @next_body = StringIO.new(String.new(capacity: body_size))
+        @next_body_size = body_size
       end
     end
 
-    def on_return(&block)
-      @on_return = block
+    def body_delivered(body_part)
+      @next_body.write(body_part)
+      return unless @next_body.pos == @next_body_size
+
+      @next_msg.body = @next_body.string
+      next_message_finished!
+    end
+
+    def close_consumer(tag)
+      @consumers.fetch(tag).close
     end
 
     private
 
-    def recv_deliveries(consumer_tag, deliver_queue, msgs)
-      loop do
-        _, delivery_tag, redelivered, exchange, routing_key = deliver_queue.shift || raise(ClosedQueueError)
-        body_size, properties = expect(:header)
-        body = String.new("", capacity: body_size)
-        while body.bytesize < body_size
-          body_part, = expect(:body)
-          body += body_part
+    def next_message_finished!
+      next_msg = @next_msg
+      if next_msg.is_a? ReturnMessage
+        if @on_return
+          Thread.new { @on_return.call(next_msg) }
+        else
+          warn "AMQP-Client message returned: #{msg.inspect}"
         end
-        msgs.push Message.new(self, delivery_tag, exchange, routing_key, properties, body, redelivered, consumer_tag)
+      elsif next_msg.consumer_tag.nil?
+        @basic_gets.push next_msg
+      else
+        Thread.pass until (consumer = @consumers[next_msg.consumer_tag])
+        consumer.push next_msg
       end
     ensure
-      msgs.close
+      @next_msg = @next_body = @next_body_size = nil
     end
 
     def write_bytes(*bytes)
@@ -296,13 +330,11 @@ module AMQP
     end
 
     def expect(expected_frame_type)
-      loop do
-        frame_type, *args = @replies.shift
-        raise AMQP::Client::ChannelClosedError.new(@id, *@closed) if frame_type.nil?
-        return args if frame_type == expected_frame_type
+      frame_type, *args = @replies.pop
+      raise AMQP::Client::ChannelClosedError.new(@id, *@closed) if frame_type.nil?
+      raise AMQP::Client::UnexpectedFrame.new(expected_frame_type, frame_type) unless frame_type == expected_frame_type
 
-        @replies.push [frame_type, *args]
-      end
+      args
     end
   end
 end

data/lib/amqp/client/connection.rb

@@ -10,12 +10,10 @@ require_relative "./errors"
 module AMQP
   # Represents a single AMQP connection
   class Connection
-    def self.connect(uri, **options)
-      read_loop_thread = options[:read_loop_thread] || true
-
+    def self.connect(uri, read_loop_thread: true, **options)
       uri = URI.parse(uri)
       tls = uri.scheme == "amqps"
-      port = port_from_env || uri.port || (@tls ? 5671 : 5672)
+      port = port_from_env || uri.port || (tls ? 5671 : 5672)
       host = uri.host || "localhost"
       user = uri.user || "guest"
       password = uri.password || "guest"
@@ -25,10 +23,16 @@ module AMQP
       socket = Socket.tcp host, port, connect_timeout: 20, resolv_timeout: 5
       enable_tcp_keepalive(socket)
       if tls
+        cert_store = OpenSSL::X509::Store.new
+        cert_store.set_default_paths
         context = OpenSSL::SSL::SSLContext.new
+        context.cert_store = cert_store
         context.verify_mode = OpenSSL::SSL::VERIFY_PEER unless [false, "false", "none"].include? options[:verify_peer]
         socket = OpenSSL::SSL::SSLSocket.new(socket, context)
         socket.sync_close = true # closing the TLS socket also closes the TCP socket
+        socket.hostname = host # SNI host
+        socket.connect
+        socket.post_connection_check(host) || raise(AMQP::Client::Error, "TLS certificate hostname doesn't match requested")
       end
       channel_max, frame_max, heartbeat = establish(socket, user, password, vhost, **options)
       Connection.new(socket, channel_max, frame_max, heartbeat, read_loop_thread: read_loop_thread)
@@ -36,22 +40,35 @@ module AMQP
 
     def initialize(socket, channel_max, frame_max, heartbeat, read_loop_thread: true)
       @socket = socket
-      @channel_max = channel_max
+      @channel_max = channel_max.zero? ? 65_536 : channel_max
       @frame_max = frame_max
       @heartbeat = heartbeat
       @channels = {}
       @closed = false
       @replies = Queue.new
+      @write_lock = Mutex.new
       Thread.new { read_loop } if read_loop_thread
     end
 
     attr_reader :frame_max
 
+    def inspect
+      "#<#{self.class} @closed=#{@closed} channel_count=#{@channels.size}>"
+    end
+
     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
+
       if id
         ch = @channels[id] ||= Channel.new(self, id)
       else
-        id = 1.upto(@channel_max) { |i| break i unless @channels.key? i }
+        id = nil
+        1.upto(@channel_max) do |i|
+          break id = i unless @channels.key? i
+        end
+        raise AMQP::Client::Error, "Max channels reached" if id.nil?
+
         ch = @channels[id] = Channel.new(self, id)
       end
       ch.open
@@ -70,9 +87,10 @@ module AMQP
     def close(reason = "", code = 200)
       return if @closed
 
+      @closed = true
       write_bytes FrameBytes.connection_close(code, reason)
+      @channels.each_value { |ch| ch.closed!(code, reason, 0, 0) }
       expect(:close_ok)
-      @closed = true
     end
 
     def closed?
@@ -80,47 +98,51 @@ module AMQP
     end
 
     def write_bytes(*bytes)
-      @socket.write(*bytes)
+      if @socket.is_a? OpenSSL::SSL::SSLSocket
+        @write_lock.synchronize do
+          @socket.write(*bytes)
+        end
+      else
+        @socket.write(*bytes)
+      end
     rescue IOError, OpenSSL::OpenSSLError, SystemCallError => e
-      raise AMQP::Client::Error.new("Could not write to socket", cause: e)
+      raise AMQP::Client::Error, "Could not write to socket, #{e.message}"
     end
 
     # Reads from the socket, required for any kind of progress. Blocks until the connection is closed
     def read_loop
+      # read more often than write so that channel errors crop up early
+      Thread.current.priority += 1
       socket = @socket
       frame_max = @frame_max
-      buffer = String.new(capacity: frame_max)
+      frame_start = String.new(capacity: 7)
+      frame_buffer = String.new(capacity: frame_max)
       loop do
-        begin
-          socket.readpartial(frame_max, buffer)
-        rescue IOError, OpenSSL::OpenSSLError, SystemCallError
-          break
+        socket.read(7, frame_start)
+        type, channel_id, frame_size = frame_start.unpack("C S> L>")
+        if frame_size > frame_max
+          raise AMQP::Client::Error, "Frame size #{frame_size} is larger than negotiated max frame size #{frame_max}"
         end
 
-        pos = 0
-        while pos < buffer.bytesize
-          buffer += socket.read(pos + 8 - buffer.bytesize) if pos + 8 > buffer.bytesize
-          type, channel_id, frame_size = buffer.byteslice(pos, 7).unpack("C S> L>")
-          if frame_size > frame_max
-            raise AMQP::Client::Error, "Frame size #{frame_size} larger than negotiated max frame size #{frame_max}"
-          end
+        # read the frame content
+        socket.read(frame_size, frame_buffer)
 
-          frame_end_pos = pos + 7 + frame_size
-          buffer += socket.read(frame_end_pos - buffer.bytesize + 1) if frame_end_pos + 1 > buffer.bytesize
-          frame_end = buffer[frame_end_pos].ord
-          raise AMQP::Client::UnexpectedFrameEnd, frame_end if frame_end != 206
+        # make sure that the frame end is correct
+        frame_end = socket.readchar.ord
+        raise AMQP::Client::UnexpectedFrameEnd, frame_end if frame_end != 206
 
-          buf = buffer.byteslice(pos, frame_size + 8)
-          pos += frame_size + 8
-          parse_frame(type, channel_id, frame_size, buf) || return
-        end
+        # parse the frame, will return false if a close frame was received
+        parse_frame(type, channel_id, frame_size, frame_buffer) || return
       end
+    rescue IOError, OpenSSL::OpenSSLError, SystemCallError => e
+      warn "AMQP-Client read error: #{e.inspect}"
+      nil # ignore read errors
     ensure
       @closed = true
       @replies.close
       begin
         @socket.close
-      rescue IOError
+      rescue IOError, OpenSSL::OpenSSLError, SystemCallError
         nil
       end
     end
@@ -130,20 +152,26 @@ module AMQP
     def parse_frame(type, channel_id, frame_size, buf)
       case type
       when 1 # method frame
-        class_id, method_id = buf.unpack("@7 S> S>")
+        class_id, method_id = buf.unpack("S> S>")
         case class_id
         when 10 # connection
           raise AMQP::Client::Error, "Unexpected channel id #{channel_id} for Connection frame" if channel_id != 0
 
           case method_id
           when 50 # connection#close
-            code, text_len = buf.unpack("@11 S> C")
-            text = buf.byteslice(14, text_len).force_encoding("utf-8")
-            error_class_id, error_method_id = buf.byteslice(14 + text_len, 4).unpack("S> S>")
-            warn "Connection closed #{code} #{text} #{error_class_id} #{error_method_id}"
-            write_bytes FrameBytes.connection_close_ok
+            @closed = true
+            code, text_len = buf.unpack("@4 S> C")
+            text = buf.byteslice(7, text_len).force_encoding("utf-8")
+            error_class_id, error_method_id = buf.byteslice(7 + text_len, 4).unpack("S> S>")
+            @channels.each_value { |ch| ch.closed!(code, text, error_class_id, error_method_id) }
+            begin
+              write_bytes FrameBytes.connection_close_ok
+            rescue AMQP::Client::Error
+              nil # rabbitmq closes the socket after sending Connection::Close, so ignore write errors
+            end
             return false
           when 51 # connection#close-ok
+            @closed = true
             @replies.push [:close_ok]
             return false
           else raise AMQP::Client::UnsupportedMethodFrame, class_id, method_id
@@ -153,13 +181,15 @@ module AMQP
           when 11 # channel#open-ok
             @channels[channel_id].reply [:channel_open_ok]
           when 40 # channel#close
-            reply_code, reply_text_len = buf.unpack("@11 S> C")
-            reply_text = buf.byteslice(14, reply_text_len).force_encoding("utf-8")
-            classid, methodid = buf.byteslice(14 + reply_text_len, 4).unpack("S> S>")
+            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.delete(channel_id)
             channel.closed!(reply_code, reply_text, classid, methodid)
+            write_bytes FrameBytes.channel_close_ok(channel_id)
           when 41 # channel#close-ok
-            @channels[channel_id].reply [:channel_close_ok]
+            channel = @channels.delete(channel_id)
+            channel.reply [:channel_close_ok]
           else raise AMQP::Client::UnsupportedMethodFrame, class_id, method_id
           end
         when 40 # exchange
@@ -177,16 +207,16 @@ module AMQP
         when 50 # queue
           case method_id
           when 11 # declare-ok
-            queue_name_len = buf.unpack1("@11 C")
-            queue_name = buf.byteslice(12, queue_name_len).force_encoding("utf-8")
-            message_count, consumer_count = buf.byteslice(12 + queue_name_len, 8).unpack1("L> L>")
+            queue_name_len = buf.unpack1("@4 C")
+            queue_name = buf.byteslice(5, queue_name_len).force_encoding("utf-8")
+            message_count, consumer_count = buf.byteslice(5 + queue_name_len, 8).unpack("L> L>")
             @channels[channel_id].reply [:queue_declare_ok, queue_name, message_count, consumer_count]
           when 21 # bind-ok
             @channels[channel_id].reply [:queue_bind_ok]
           when 31 # purge-ok
             @channels[channel_id].reply [:queue_purge_ok]
           when 41 # delete-ok
-            message_count = buf.unpack1("@11 L>")
+            message_count = buf.unpack1("@4 L>")
             @channels[channel_id].reply [:queue_delete, message_count]
           when 51 # unbind-ok
             @channels[channel_id].reply [:queue_unbind_ok]
@@ -197,22 +227,22 @@ module AMQP
           when 11 # qos-ok
             @channels[channel_id].reply [:basic_qos_ok]
           when 21 # consume-ok
-            tag_len = buf.unpack1("@11 C")
-            tag = buf.byteslice(12, tag_len).force_encoding("utf-8")
+            tag_len = buf.unpack1("@4 C")
+            tag = buf.byteslice(5, tag_len).force_encoding("utf-8")
             @channels[channel_id].reply [:basic_consume_ok, tag]
           when 30 # cancel
-            tag_len = buf.unpack1("@11 C")
-            tag = buf.byteslice(12, tag_len).force_encoding("utf-8")
-            no_wait = buf[12 + tag_len].ord
-            @channels[channel_id].consumers.fetch(tag).close
+            tag_len = buf.unpack1("@4 C")
+            tag = buf.byteslice(5, tag_len).force_encoding("utf-8")
+            no_wait = buf[5 + tag_len].ord
+            @channels[channel_id].close_consumer(tag)
             write_bytes FrameBytes.basic_cancel_ok(@id, tag) unless no_wait == 1
           when 31 # cancel-ok
-            tag_len = buf.unpack1("@11 C")
-            tag = buf.byteslice(12, tag_len).force_encoding("utf-8")
+            tag_len = buf.unpack1("@4 C")
+            tag = buf.byteslice(5, tag_len).force_encoding("utf-8")
             @channels[channel_id].reply [:basic_cancel_ok, tag]
           when 50 # return
-            reply_code, reply_text_len = buf.unpack("@11 S> C")
-            pos = 14
+            reply_code, reply_text_len = buf.unpack("@4 S> C")
+            pos = 7
             reply_text = buf.byteslice(pos, reply_text_len).force_encoding("utf-8")
             pos += reply_text_len
             exchange_len = buf[pos].ord
@@ -224,9 +254,9 @@ module AMQP
             routing_key = buf.byteslice(pos, routing_key_len).force_encoding("utf-8")
             @channels[channel_id].message_returned(reply_code, reply_text, exchange, routing_key)
           when 60 # deliver
-            ctag_len = buf[11].ord
-            consumer_tag = buf.byteslice(12, ctag_len).force_encoding("utf-8")
-            pos = 12 + ctag_len
+            ctag_len = buf[4].ord
+            consumer_tag = buf.byteslice(5, ctag_len).force_encoding("utf-8")
+            pos = 5 + ctag_len
             delivery_tag, redelivered, exchange_len = buf.byteslice(pos, 10).unpack("Q> C C")
             pos += 8 + 1 + 1
             exchange = buf.byteslice(pos, exchange_len).force_encoding("utf-8")
@@ -234,38 +264,27 @@ module AMQP
             rk_len = buf[pos].ord
             pos += 1
             routing_key = buf.byteslice(pos, rk_len).force_encoding("utf-8")
-            loop do
-              if (consumer = @channels[channel_id].consumers[consumer_tag])
-                consumer.push [:deliver, delivery_tag, redelivered == 1, exchange, routing_key]
-                break
-              else
-                Thread.pass
-              end
-            end
+            @channels[channel_id].message_delivered(consumer_tag, delivery_tag, redelivered == 1, exchange, routing_key)
           when 71 # get-ok
-            delivery_tag, redelivered, exchange_len = buf.unpack("@11 Q> C C")
-            pos = 21
+            delivery_tag, redelivered, exchange_len = buf.unpack("@4 Q> C C")
+            pos = 14
             exchange = buf.byteslice(pos, exchange_len).force_encoding("utf-8")
             pos += exchange_len
             routing_key_len = buf[pos].ord
             pos += 1
             routing_key = buf.byteslice(pos, routing_key_len).force_encoding("utf-8")
             pos += routing_key_len
-            message_count = buf.byteslice(pos, 4).unpack1("L>")
-            redelivered = redelivered == 1
-            @channels[channel_id].reply [:basic_get_ok, delivery_tag, exchange, routing_key, message_count, redelivered]
+            _message_count = buf.byteslice(pos, 4).unpack1("L>")
+            @channels[channel_id].message_delivered(nil, delivery_tag, redelivered == 1, exchange, routing_key)
           when 72 # get-empty
-            @channels[channel_id].reply [:basic_get_empty]
+            @channels[channel_id].basic_get_empty
           when 80 # ack
-            delivery_tag, multiple = buf.unpack("@11 Q> C")
-            @channels[channel_id].confirm [:ack, delivery_tag, multiple]
-          when 90 # reject
-            delivery_tag, requeue = buf.unpack("@11 Q> C")
-            @channels[channel_id].confirm [:reject, delivery_tag, requeue == 1]
+            delivery_tag, multiple = buf.unpack("@4 Q> C")
+            @channels[channel_id].confirm [:ack, delivery_tag, multiple == 1]
           when 111 # recover-ok
             @channels[channel_id].reply [:basic_recover_ok]
           when 120 # nack
-            delivery_tag, multiple, requeue = buf.unpack("@11 Q> C C")
+            delivery_tag, multiple, requeue = buf.unpack("@4 Q> C C")
             @channels[channel_id].confirm [:nack, delivery_tag, multiple == 1, requeue == 1]
           else raise AMQP::Client::UnsupportedMethodFrame.new class_id, method_id
           end
@@ -288,20 +307,19 @@ module AMQP
         else raise AMQP::Client::UnsupportedMethodFrame.new class_id, method_id
         end
       when 2 # header
-        body_size = buf.unpack1("@11 Q>")
-        properties = Properties.decode(buf.byteslice(19, buf.bytesize - 20))
-        @channels[channel_id].reply [:header, body_size, properties]
+        body_size = buf.unpack1("@4 Q>")
+        properties = Properties.decode(buf.byteslice(12, buf.bytesize - 12))
+        @channels[channel_id].header_delivered body_size, properties
       when 3 # body
-        body = buf.byteslice(7, frame_size)
-        @channels[channel_id].reply [:body, body]
+        @channels[channel_id].body_delivered buf
       else raise AMQP::Client::UnsupportedFrameType, type
       end
       true
     end
 
     def expect(expected_frame_type)
-      frame_type, args = @replies.shift
-      frame_type == expected_frame_type || raise(UnexpectedFrame.new(expected_frame_type, frame_type))
+      frame_type, args = @replies.pop
+      frame_type == expected_frame_type || raise(AMQP::Client::UnexpectedFrame.new(expected_frame_type, frame_type))
       args
     end
 
@@ -317,7 +335,7 @@ module AMQP
         end
 
         type, channel_id, frame_size = buf.unpack("C S> L>")
-        frame_end = buf.unpack1("@#{frame_size + 7} C")
+        frame_end = buf[frame_size + 7].ord
         raise UnexpectedFrameEndError, frame_end if frame_end != 206
 
         case type
@@ -329,7 +347,8 @@ module AMQP
 
             case method_id
             when 10 # connection#start
-              properties = CLIENT_PROPERTIES.merge({ connection_name: options[:connection_name] })
+              conn_name = options[:connection_name] || $PROGRAM_NAME
+              properties = CLIENT_PROPERTIES.merge({ connection_name: conn_name })
               socket.write FrameBytes.connection_start_ok "\u0000#{user}\u0000#{password}", properties
             when 30 # connection#tune
               channel_max, frame_max, heartbeat = buf.unpack("@11 S> L> S>")
@@ -363,7 +382,7 @@ module AMQP
       socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, 10)
       socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, 3)
     rescue StandardError => e
-      warn "amqp-client: Could not enable TCP keepalive on socket. #{e.inspect}"
+      warn "AMQP-Client could not enable TCP keepalive on socket. #{e.inspect}"
     end
 
     def self.port_from_env

data/lib/amqp/client/message.rb

@@ -7,7 +7,7 @@ module AMQP
     end
 
     def reject(requeue: false)
-      channel.basic_reject(delivery_tag, requeue)
+      channel.basic_reject(delivery_tag, requeue: requeue)
     end
   end
 

data/lib/amqp/client/properties.rb

@@ -38,7 +38,8 @@ module AMQP
       end
 
       if delivery_mode
-        headers.is_a?(Integer) || raise(ArgumentError, "delivery_mode must be an int")
+        delivery_mode.is_a?(Integer) || raise(ArgumentError, "delivery_mode must be an int")
+        delivery_mode.between?(0, 2) || raise(ArgumentError, "delivery_mode must be be between 0 and 2")
 
         flags |= (1 << 12)
         arr << delivery_mode
@@ -69,7 +70,8 @@ module AMQP
       end
 
       if expiration
-        expiration.is_a?(String) || raise(ArgumentError, "expiration must be a string")
+        self.expiration = expiration.to_s if expiration.is_a?(Integer)
+        expiration.is_a?(String) || raise(ArgumentError, "expiration must be a string or integer")
 
         flags |= (1 << 8)
         arr << expiration.bytesize << expiration
@@ -85,7 +87,7 @@ module AMQP
       end
 
       if timestamp
-        timestamp.is_a?(Time) || raise(ArgumentError, "timestamp must be a time")
+        timestamp.is_a?(Integer) || timestamp.is_a?(Time) || raise(ArgumentError, "timestamp must be an Integer or a Time")
 
         flags |= (1 << 6)
         arr << timestamp.to_i

data/lib/amqp/client/version.rb

@@ -2,6 +2,6 @@
 
 module AMQP
   class Client
-    VERSION = "0.2.1"
+    VERSION = "1.0.0"
   end
 end

data/lib/amqp/client.rb

@@ -12,31 +12,41 @@ module AMQP
       @options = options
 
       @queues = {}
+      @exchanges = {}
       @subscriptions = Set.new
       @connq = SizedQueue.new(1)
     end
 
+    # Opens an AMQP connection, does not try to reconnect
     def connect(read_loop_thread: true)
-      Connection.connect(@uri, **@options.merge(read_loop_thread: read_loop_thread))
+      Connection.connect(@uri, read_loop_thread: read_loop_thread, **@options)
     end
 
+    # Opens an AMQP connection using the high level API, will try to reconnect
     def start
       @stopped = false
-      Thread.new do
+      Thread.new(connect(read_loop_thread: false)) do |conn|
+        Thread.abort_on_exception = true # Raising an unhandled exception is a bug
         loop do
           break if @stopped
 
-          conn = connect(read_loop_thread: false)
+          conn ||= connect(read_loop_thread: false)
           Thread.new do
             # restore connection in another thread, read_loop have to run
             conn.channel(1) # reserve channel 1 for publishes
-            @subscriptions.each { |args| subscribe(*args) }
+            @subscriptions.each do |queue_name, no_ack, prefetch, wt, args, blk|
+              ch = conn.channel
+              ch.basic_qos(prefetch)
+              ch.basic_consume(queue_name, no_ack: no_ack, worker_threads: wt, arguments: args, &blk)
+            end
             @connq << conn
           end
           conn.read_loop # blocks until connection is closed, then reconnect
-        rescue => e
+        rescue AMQP::Client::Error => e
           warn "AMQP-Client reconnect error: #{e.inspect}"
           sleep @options[:reconnect_interval] || 1
+        ensure
+          conn = nil
         end
       end
       self
@@ -49,21 +59,58 @@ module AMQP
       nil
     end
 
-    def queue(name, arguments: {})
+    def queue(name, durable: true, exclusive: false, auto_delete: false, arguments: {})
       raise ArgumentError, "Currently only supports named, durable queues" if name.empty?
 
       @queues.fetch(name) do
         with_connection do |conn|
           conn.with_channel do |ch| # use a temp channel in case the declaration fails
-            ch.queue_declare(name, arguments: arguments)
+            ch.queue_declare(name, durable: durable, exclusive: exclusive, auto_delete: auto_delete, arguments: arguments)
           end
         end
         @queues[name] = Queue.new(self, name)
       end
     end
 
+    def exchange(name, type, durable: true, auto_delete: false, internal: false, arguments: {})
+      @exchanges.fetch(name) do
+        with_connection do |conn|
+          conn.with_channel do |ch|
+            ch.exchange_declare(name, type, durable: durable, auto_delete: auto_delete, internal: internal, arguments: arguments)
+          end
+        end
+        @exchanges[name] = Exchange.new(self, name)
+      end
+    end
+
+    # High level representation of an exchange
+    class Exchange
+      def initialize(client, name)
+        @client = client
+        @name = name
+      end
+
+      def publish(body, routing_key, arguments: {})
+        @client.publish(body, @name, routing_key, arguments: arguments)
+      end
+
+      # Bind to another exchange
+      def bind(exchange, routing_key, arguments: {})
+        @client.exchange_bind(@name, exchange, routing_key, arguments: arguments)
+      end
+
+      # Unbind from another exchange
+      def unbind(exchange, routing_key, arguments: {})
+        @client.exchange_unbind(@name, exchange, routing_key, arguments: arguments)
+      end
+
+      def delete
+        @client.delete_exchange(@name)
+      end
+    end
+
     def subscribe(queue_name, no_ack: false, prefetch: 1, worker_threads: 1, arguments: {}, &blk)
-      @subscriptions.add? [queue_name, no_ack, prefetch, arguments, blk]
+      @subscriptions.add? [queue_name, no_ack, prefetch, worker_threads, arguments, blk]
 
       with_connection do |conn|
         ch = conn.channel
@@ -74,28 +121,49 @@ module AMQP
       end
     end
 
+    # Publish a (persistent) message and wait for confirmation
     def publish(body, exchange, routing_key, **properties)
       with_connection do |conn|
-        # Use channel 1 for publishes
+        properties = { delivery_mode: 2 }.merge!(properties)
         conn.channel(1).basic_publish_confirm(body, exchange, routing_key, **properties)
-      rescue
-        conn.channel(1) # reopen channel 1 if it raised
-        raise
       end
-    rescue => e
-      warn "AMQP-Client error publishing, retrying (#{e.inspect})"
-      retry
     end
 
-    def bind(queue, exchange, routing_key, **headers)
+    # Publish a (persistent) message but don't wait for a confirmation
+    def publish_and_forget(body, exchange, routing_key, **properties)
       with_connection do |conn|
-        conn.channel(1).queue_bind(queue, exchange, routing_key, **headers)
+        properties = { delivery_mode: 2 }.merge!(properties)
+        conn.channel(1).basic_publish(body, exchange, routing_key, **properties)
       end
     end
 
-    def unbind(queue, exchange, routing_key, **headers)
+    def wait_for_confirms
       with_connection do |conn|
-        conn.channel(1).queue_unbind(queue, exchange, routing_key, **headers)
+        conn.channel(1).wait_for_confirms
+      end
+    end
+
+    def bind(queue, exchange, routing_key, arguments: {})
+      with_connection do |conn|
+        conn.channel(1).queue_bind(queue, exchange, routing_key, arguments: arguments)
+      end
+    end
+
+    def unbind(queue, exchange, routing_key, arguments: {})
+      with_connection do |conn|
+        conn.channel(1).queue_unbind(queue, exchange, routing_key, arguments: arguments)
+      end
+    end
+
+    def exchange_bind(destination, source, routing_key, arguments: {})
+      with_connection do |conn|
+        conn.channel(1).exchange_bind(destination, source, routing_key, arguments: arguments)
+      end
+    end
+
+    def exchange_unbind(destination, source, routing_key, arguments: {})
+      with_connection do |conn|
+        conn.channel(1).exchange_unbind(destination, source, routing_key, arguments: arguments)
       end
     end
 
@@ -105,9 +173,17 @@ module AMQP
       end
     end
 
-    def delete_queue(queue)
+    def delete_queue(name)
+      with_connection do |conn|
+        conn.channel(1).queue_delete(name)
+        @queues.delete(name)
+      end
+    end
+
+    def delete_exchange(name)
       with_connection do |conn|
-        conn.channel(1).queue_delete(queue)
+        conn.channel(1).exchange_delete(name)
+        @exchanges.delete(name)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: amqp-client
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Carl Hörberg
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-19 00:00:00.000000000 Z
+date: 2021-08-27 00:00:00.000000000 Z
 dependencies: []
 description: Work in progress
 email:
@@ -61,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: AMQP 0-9-1 client