amqp-client 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59f619f7aec324221f4c5dd66a10e5e30b1904a224d34702f94f9f75ac19f1c3
-  data.tar.gz: 4d3e3fc1234f44ab741b15b61156617a7f8f181ce5fdc2aacbbc4c07a787129e
+  metadata.gz: ec3129a38420f19de4c0225aea1eaefc320463c6e032c54990a998f7654f8347
+  data.tar.gz: 3c8da5fccb818730958f47fdaf78837524381b116a322adaf585ee02d0492b2d
 SHA512:
-  metadata.gz: 6ade93665b42b3c64ebed869be2af64cde53b259a6f376483c8c4d7e9de6432e2453be88caddf58655c249ae0d531a924348eb97c92b0a6a21b13a3276e3019b
-  data.tar.gz: '0479fe0b0c6f120e4bf0c5b72b905d7946037f8b5e1d83f462c18c2df790c8ed67ff5e32be693deac570d7d82dc9411875f252384364feea3b6e8b85c6abd27d'
+  metadata.gz: 24b592bb7fc50f29499e32ca6348f2aa25bac9837e694740346fa24e1fe6c45c9f9ab6497f066ca6491c6f09e558b29ac3a1d84f5b31a3b2b68bb8c28cdf76e7
+  data.tar.gz: 6ad3e059d311894f4a023d75df89c72beb4508a2abc83083a47f4f7a07cc6f98edc157e06b5ed42eda55458612d89206de1cce4b0cc94fd598facad4433083e9

data/.github/workflows/main.yml

@@ -19,7 +19,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['2.7', '3.0']
+        ruby: ['2.6', '2.7', '3.0']
     steps:
     - uses: actions/checkout@v2
     - name: Set up Ruby
@@ -32,4 +32,3 @@ jobs:
         bundle exec rake
       env:
         AMQP_PORT: ${{ job.services.rabbitmq.ports[5672] }}
-

data/.rubocop.yml

@@ -1,7 +1,7 @@
 inherit_from: .rubocop_todo.yml
 
 AllCops:
-  TargetRubyVersion: 2.5
+  TargetRubyVersion: 2.6
 
 Style/StringLiterals:
   Enabled: true

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [1.1.0] - 2021-09-08
+
+- Fixed: Due to a race condition publishers could get stuck waiting for publish confirms
+- Change: Message, ReturnMessage and Properties are now classes and not structs (for performance reasons)
+- Added: Ruby 2.6 support
+- Added: RBS signatures in sig/amqp-client.rbs
+
 ## [1.0.2] - 2021-09-07
 
 - Changed: Raise ConnectionClosed and ChannelClosed correctly (previous always ChannelClosed)

data/Gemfile

@@ -10,3 +10,7 @@ gem "rake", "~> 13.0"
 gem "minitest", "~> 5.0"
 
 gem "rubocop", "~> 1.7"
+
+gem "yard", require: false
+
+gem "rubocop-minitest", require: false

data/README.md

@@ -1,58 +1,63 @@
 # AMQP::Client
 
-An AMQP 0-9-1 Ruby client, trying to keep things as simple as possible.
+A modern AMQP 0-9-1 Ruby client. Very fast (just as fast as the Java client, and >4x than other Ruby clients), fully thread-safe, blocking operations and straight-forward error handling.
+
+## Support
+
+The library is fully supported by [CloudAMQP](https://www.cloudamqp.com), the largest RabbitMQ hosting provider in the world. Open [an issue](https://github.com/cloudamqp/amqp-client.rb/issues) or [email our support](mailto:support@cloudamqp.com) if you have problems or questions.
 
 ## Documentation
 
 [API reference](https://cloudamqp.github.io/amqp-client.rb/)
 
-## Installation
+## Usage
 
-Add this line to your application's Gemfile:
+The client has two APIs.
 
-```ruby
-gem 'amqp-client'
-```
+### Low level API
 
-And then execute:
+This API matches the AMQP protocol very well, it can do everything the protocol allows, but requires some knowledge about the protocol, and doesn't handle reconnects.
 
-    $ bundle install
+```ruby
+require "amqp-client"
 
-Or install it yourself as:
+# Opens and establishes a connection
+conn = AMQP::Client.new("amqp://guest:guest@localhost").connect
 
-    $ gem install amqp-client
+# Open a channel
+ch = conn.channel
 
-## Usage
+# Create a temporary queue
+q = ch.queue_declare
 
-Low level API
+# Publish a message to said queue
+ch.basic_publish "Hello World!", "", q.queue_name
 
-```ruby
-require "amqp-client"
+# Poll the queue for a message
+msg = ch.basic_get q.queue_name
 
-c = AMQP::Client.new("amqp://guest:guest@localhost")
-conn = c.connect
-ch = conn.channel
-q = ch.queue_declare
-ch.basic_publish "Hello World!", "", q[:queue_name]
-msg = ch.basic_get q[:queue_name]
+# Print the message's body to STDOUT
 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 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 broker).
+### High level API
+
+The library provides a high-level API that is a bit easier to get started with, and also handles reconnection automatically.
 
 ```ruby
-amqp = AMQP::Client.new("amqp://localhost")
-amqp.start
+# Start the client, it will connect and once connected it will reconnect if that connection is lost
+# Operation pending when the connection is lost will raise an exception (not timeout)
+amqp = AMQP::Client.new("amqp://localhost").start
 
 # Declares a durable queue
-q = amqp.queue("myqueue")
+myqueue = amqp.queue("myqueue")
 
 # Bind the queue to any exchange, with any binding key
-q.bind("amq.topic", "my.events.*")
+myqueue.bind("amq.topic", "my.events.*")
 
 # The message will be reprocessed if the client loses connection to the broker
 # between message arrival and when the message was supposed to be ack'ed.
-q.subscribe(prefetch: 20) do |msg|
+myqueue.subscribe(prefetch: 20) do |msg|
   process(JSON.parse(msg.body))
   msg.ack
 rescue
@@ -60,13 +65,37 @@ rescue
 end
 
 # Publish directly to the queue
-q.publish { foo: "bar" }.to_json, content_type: "application/json"
+myqueue.publish({ foo: "bar" }.to_json, content_type: "application/json")
 
 # Publish to any exchange
 amqp.publish("my message", "amq.topic", "topic.foo", headers: { foo: 'bar' })
 amqp.publish(Zlib.gzip("an event"), "amq.topic", "my.event", content_encoding: 'gzip')
 ```
 
+## Supported Ruby versions
+
+All maintained Ruby versions are supported.
+
+- 3.0
+- 2.7
+- 2.6
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'amqp-client'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install amqp-client
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -11,6 +11,8 @@ end
 
 require "rubocop/rake_task"
 
-RuboCop::RakeTask.new
+RuboCop::RakeTask.new do |task|
+  task.requires << "rubocop-minitest"
+end
 
 task default: %i[test rubocop]

data/amqp-client.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = "Work in progress"
   spec.homepage      = "https://github.com/cloudamqp/amqp-client.rb"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "#{spec.homepage}.git"

data/lib/amqp/client/channel.rb

@@ -215,6 +215,7 @@ module AMQP
         def queue_unbind(name, exchange, binding_key, arguments: {})
           write_bytes FrameBytes.queue_unbind(@id, name, exchange, binding_key, arguments)
           expect :queue_unbind_ok
+          nil
         end
 
         # @!endgroup
@@ -411,11 +412,10 @@ module AMQP
         def wait_for_confirms
           return true if @unconfirmed.empty?
 
-          case @unconfirmed_empty.pop
-          when true then true
-          when false then false
-          else raise Error::Closed.new(@id, *@closed)
-          end
+          ok = @unconfirmed_empty.pop
+          raise Error::Closed.new(@id, *@closed) if ok.nil?
+
+          ok
         end
 
         # Called by Connection when received ack/nack from broker
@@ -433,9 +433,8 @@ module AMQP
           end
           return unless @unconfirmed.empty?
 
-          @unconfirmed_empty.num_waiting.times do
-            @unconfirmed_empty << (ack_or_nack == :ack)
-          end
+          ok = ack_or_nack == :ack
+          @unconfirmed_empty.push(ok) until @unconfirmed_empty.num_waiting.zero?
         end
 
         # @!endgroup
@@ -474,12 +473,12 @@ module AMQP
 
         # @api private
         def message_returned(reply_code, reply_text, exchange, routing_key)
-          @next_msg = ReturnMessage.new(reply_code, reply_text, exchange, routing_key, nil, "")
+          @next_msg = ReturnMessage.new(reply_code, reply_text, exchange, routing_key)
         end
 
         # @api private
         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)
+          @next_msg = Message.new(self, consumer_tag, delivery_tag, exchange, routing_key, redelivered)
         end
 
         # @api private
@@ -510,6 +509,7 @@ module AMQP
         # @api private
         def close_consumer(tag)
           @consumers.fetch(tag).close
+          nil
         end
 
         private
@@ -528,6 +528,7 @@ module AMQP
             Thread.pass until (consumer = @consumers[next_msg.consumer_tag])
             consumer.push next_msg
           end
+          nil
         ensure
           @next_msg = @next_body = @next_body_size = nil
         end

data/lib/amqp/client/connection.rb

@@ -13,47 +13,31 @@ module AMQP
     class Connection
       # Establish a connection to an AMQP broker
       # @param uri [String] URL on the format amqp://username:password@hostname/vhost, use amqps:// for encrypted connection
-      # @param read_loop_thread [Boolean] Set to false if you manually want to run the {#read_loop}
+      # @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
       # @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
+      # @option options [Integer] connect_timeout (30) TCP connection timeout
       # @option options [Integer] heartbeat (0) Heartbeat timeout, defaults to 0 and relies on TCP keepalive instead
       # @option options [Integer] frame_max (131_072) Maximum frame size,
       #    the smallest of the client's and the broker's values will be used
       # @option options [Integer] channel_max (2048) Maxium number of channels the client will be allowed to have open.
       #   Maxium allowed is 65_536.  The smallest of the client's and the broker's value will be used.
       # @return [Connection]
-      def self.connect(uri, read_loop_thread: true, **options)
+      def initialize(uri = "", read_loop_thread: true, **options)
         uri = URI.parse(uri)
         tls = uri.scheme == "amqps"
         port = port_from_env || uri.port || (tls ? 5671 : 5672)
         host = uri.host || "localhost"
         user = uri.user || "guest"
         password = uri.password || "guest"
-        vhost = URI.decode_www_form_component(uri.path[1..-1] || "/")
+        vhost = URI.decode_www_form_component(uri.path[1..] || "/")
         options = URI.decode_www_form(uri.query || "").map! { |k, v| [k.to_sym, v] }.to_h.merge(options)
 
-        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(Error, "TLS certificate hostname doesn't match requested")
-        end
+        socket = open_socket(host, port, tls, options)
         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)
-      end
 
-      # Requires an already established TCP/TLS socket
-      # @api private
-      def initialize(socket, channel_max, frame_max, heartbeat, read_loop_thread: true)
         @socket = socket
         @channel_max = channel_max.zero? ? 65_536 : channel_max
         @frame_max = frame_max
@@ -66,6 +50,13 @@ module AMQP
         Thread.new { read_loop } if read_loop_thread
       end
 
+      # Alias for {#initialize}
+      # @see #initialize
+      # @deprecated
+      def self.connect(uri, read_loop_thread: true, **options)
+        new(uri, read_loop_thread: read_loop_thread, **options)
+      end
+
       # The max frame size negotiated between the client and the broker
       # @return [Integer]
       attr_reader :frame_max
@@ -183,7 +174,9 @@ module AMQP
         @closed ||= [400, "unknown"]
         @replies.close
         begin
-          @socket.close
+          @write_lock.synchronize do
+            @socket.close
+          end
         rescue IOError, OpenSSL::OpenSSLError, SystemCallError
           nil
         end
@@ -216,7 +209,7 @@ module AMQP
               @replies.push [:close_ok]
               return false
             when 60 # connection#blocked
-              reason_len = buf.unpack1("@4 C")
+              reason_len = buf.getbyte(4)
               reason = buf.byteslice(5, reason_len).force_encoding("utf-8")
               @blocked = reason
               @write_lock.lock
@@ -256,7 +249,7 @@ module AMQP
           when 50 # queue
             case method_id
             when 11 # declare-ok
-              queue_name_len = buf.unpack1("@4 C")
+              queue_name_len = buf.getbyte(4)
               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]
@@ -276,17 +269,17 @@ module AMQP
             when 11 # qos-ok
               @channels[channel_id].reply [:basic_qos_ok]
             when 21 # consume-ok
-              tag_len = buf.unpack1("@4 C")
+              tag_len = buf.getbyte(4)
               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("@4 C")
+              tag_len = buf.getbyte(4)
               tag = buf.byteslice(5, tag_len).force_encoding("utf-8")
-              no_wait = buf[5 + tag_len].ord == 1
+              no_wait = buf.getbyte(5 + tag_len) == 1
               @channels[channel_id].close_consumer(tag)
               write_bytes FrameBytes.basic_cancel_ok(@id, tag) unless no_wait
             when 31 # cancel-ok
-              tag_len = buf.unpack1("@4 C")
+              tag_len = buf.getbyte(4)
               tag = buf.byteslice(5, tag_len).force_encoding("utf-8")
               @channels[channel_id].reply [:basic_cancel_ok, tag]
             when 50 # return
@@ -294,23 +287,23 @@ module AMQP
               pos = 7
               reply_text = buf.byteslice(pos, reply_text_len).force_encoding("utf-8")
               pos += reply_text_len
-              exchange_len = buf[pos].ord
+              exchange_len = buf.getbyte(pos)
               pos += 1
               exchange = buf.byteslice(pos, exchange_len).force_encoding("utf-8")
               pos += exchange_len
-              routing_key_len = buf[pos].ord
+              routing_key_len = buf.getbyte(pos)
               pos += 1
               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[4].ord
+              ctag_len = buf.getbyte(4)
               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")
               pos += exchange_len
-              rk_len = buf[pos].ord
+              rk_len = buf.getbyte(pos)
               pos += 1
               routing_key = buf.byteslice(pos, rk_len).force_encoding("utf-8")
               @channels[channel_id].message_delivered(consumer_tag, delivery_tag, redelivered == 1, exchange, routing_key)
@@ -319,11 +312,11 @@ module AMQP
               pos = 14
               exchange = buf.byteslice(pos, exchange_len).force_encoding("utf-8")
               pos += exchange_len
-              routing_key_len = buf[pos].ord
+              routing_key_len = buf.getbyte(pos)
               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>")
+              # pos += routing_key_len
+              # 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].basic_get_empty
@@ -377,9 +370,32 @@ module AMQP
         args
       end
 
+      # Connect to the host/port, optionally establish a TLS connection
+      # @return [Socket]
+      # @return [OpenSSL::SSL::SSLSocket]
+      def open_socket(host, port, tls, options)
+        connect_timeout = options.fetch(:connect_timeout, 30).to_i
+        socket = Socket.tcp host, port, connect_timeout: connect_timeout
+        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
+          verify_peer = [false, "false", "none"].include? options[:verify_peer]
+          context.verify_mode = OpenSSL::SSL::VERIFY_PEER unless 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(Error, "TLS certificate hostname doesn't match requested")
+        end
+        socket
+      end
+
       # Negotiate a connection
       # @return [Array<Integer, Integer, Integer>] channel_max, frame_max, heartbeat
-      def self.establish(socket, user, password, vhost, options)
+      def establish(socket, user, password, vhost, options)
         channel_max, frame_max, heartbeat = nil
         socket.write "AMQP\x00\x00\x09\x01"
         buf = String.new(capacity: 4096)
@@ -391,7 +407,7 @@ module AMQP
           end
 
           type, channel_id, frame_size = buf.unpack("C S> L>")
-          frame_end = buf[frame_size + 7].ord
+          frame_end = buf.getbyte(frame_size + 7)
           raise UnexpectedFrameEndError, frame_end if frame_end != 206
 
           case type
@@ -437,7 +453,9 @@ module AMQP
         raise e
       end
 
-      def self.enable_tcp_keepalive(socket)
+      # Enable TCP keepalive, which is prefered to heartbeats
+      # @return [void]
+      def enable_tcp_keepalive(socket)
         socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
         socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, 60)
         socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, 10)
@@ -446,14 +464,15 @@ module AMQP
         warn "AMQP-Client could not enable TCP keepalive on socket. #{e.inspect}"
       end
 
-      def self.port_from_env
+      # Fetch the AMQP port number from ENV
+      # @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"])
 
         port.to_i
       end
 
-      private_class_method :establish, :enable_tcp_keepalive, :port_from_env
-
       CLIENT_PROPERTIES = {
         capabilities: {
           authentication_failure_close: true,