amqp-client 1.1.4 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e287ef0dee4c9ec581690733c12c132f74c595ceddead1ba5b95b765138e11c
-  data.tar.gz: e5462c8cd2a4f7232a51e17d9ec93f4fb2ea88a922bb9b5cc58242cced78d61e
+  metadata.gz: 10119835607b70ee73dd581f9bef3211a26fc18bb6fb7fa2f6e6bfe913076b16
+  data.tar.gz: a30989dab30c2dea294c0310bbfd211a36fa7453d935200c6b7783553f5e816c
 SHA512:
-  metadata.gz: 923fb64c7234fb6718f7dbc5eb33c1f8de03a9cf12d669539935cc6ef83f4ca387afc80c1e56fcc2ed167dc14381cda1d7b6a67673c6516818909cb6a84c287d
-  data.tar.gz: 14c4d9157cee844609eeb5beed70ee2560ba3442c5afb857fed3e0945c443910f7bd4a281e327d2cb5ee0f0896facf4c8e693e5d3ecf1152c07474e20f8a724f
+  metadata.gz: 2658a0f4e151ab9fd0a56d1096e8d6b191b5e5164e27eadb8dc922651664440149fd1eef7b9d410fbcdf781eba3ef046b141c017b3b5d317b241ec7afa2d8150
+  data.tar.gz: 73695493c9f72619279a5552bdea275f6aa781da3da1dadebb788eaff249f68e088b3eb9fc5cc7c3afab1d6df0b44bd83e18ce2aa3605ace83a00035dfd84890

data/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,41 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '23 22 * * 2'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'ruby' ]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3

data/.github/workflows/docs.yml

@@ -12,17 +12,17 @@ jobs:
   docs:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.0
+          ruby-version: ruby
       - name: Install yard
         run: gem install yard
       - name: Generate docs
         run: yard doc
       - name: Deploy docs
-        uses: JamesIves/github-pages-deploy-action@4.1.5
+        uses: JamesIves/github-pages-deploy-action@v4.5.0
         with:
           branch: gh-pages
           folder: doc

data/.github/workflows/main.yml

@@ -1,33 +1,40 @@
 name: Ruby
 
-on: [push,pull_request]
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
 
 jobs:
   tests:
+    name: >-
+      ${{ matrix.ruby }} (sudo: ${{ matrix.sudo }})
     runs-on: ubuntu-latest
-    timeout-minutes: 5
-    services:
-      rabbitmq:
-        image: rabbitmq:latest
-        ports:
-        - 5672/tcp
-        # needed because the rabbitmq container does not provide a healthcheck
-        options: >-
-          --health-cmd "rabbitmqctl node_health_check"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
+    timeout-minutes: 10
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1']
+        sudo: [true]
+        ruby:
+          - "2.6"
+          - "2.7"
+          - "3.0"
+          - "3.1"
+          - "3.2"
+          - "3.3"
         include:
-          - { ruby: jruby, allow-failure: true }
-          - { ruby: truffleruby, allow-failure: true }
+          - { ruby: jruby, allow-failure: true, sudo: false }
+          - { ruby: truffleruby, allow-failure: true, sudo: false }
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
+    - name: Install RabbitMQ
+      run: sudo apt-get update && sudo apt-get install -y rabbitmq-server
+    - name: Verify RabbitMQ started correctly
+      run: while true; do sudo rabbitmq-diagnostics status 2>/dev/null && break; echo -n .; sleep 2; done
+    - uses: actions/checkout@v4
+    - uses: ruby/setup-ruby@v1
       with:
         bundler-cache: true
         ruby-version: ${{ matrix.ruby }}
@@ -35,20 +42,25 @@ jobs:
       continue-on-error: ${{ matrix.allow-failure || false }}
       run: bundle exec rake
       env:
-        AMQP_PORT: ${{ job.services.rabbitmq.ports[5672] }}
+        RUN_SUDO_TESTS: ${{ matrix.sudo }}
+
   tls:
     runs-on: ubuntu-latest
-    timeout-minutes: 5
+    timeout-minutes: 10
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['3.0', 'jruby', 'truffleruby']
+        ruby:
+          - "ruby" # latest stable release
+          - "jruby"
+          - "truffleruby"
     steps:
     - name: Install RabbitMQ
       run: sudo apt-get update && sudo apt-get install -y rabbitmq-server
     - name: Stop RabbitMQ
       run: sudo systemctl stop rabbitmq-server
-
+    - name: Set up Homebrew
+      uses: Homebrew/actions/setup-homebrew@master
     - name: Install github.com/FiloSottile/mkcert
       run: brew install mkcert
     - name: Create local CA
@@ -69,10 +81,8 @@ jobs:
       run: sudo systemctl start rabbitmq-server
     - name: Verify RabbitMQ started correctly
       run: while true; do sudo rabbitmq-diagnostics status 2>/dev/null && break; echo -n .; sleep 2; done
-
-    - uses: actions/checkout@v2
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
+    - uses: actions/checkout@v4
+    - uses: ruby/setup-ruby@v1
       with:
         bundler-cache: true
         ruby-version: ${{ matrix.ruby }}
@@ -80,21 +90,22 @@ jobs:
       run: bundle exec rake
       env:
         TESTOPTS: --name=/_tls$/
+
   macos:
     runs-on: macos-latest
-    timeout-minutes: 5
+    timeout-minutes: 10
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['3.0']
+        ruby: # enough to test one Ruby on macOS
+          - "ruby" # latest stable release
     steps:
     - name: Install RabbitMQ
       run: brew install rabbitmq
     - name: Start RabbitMQ
       run: brew services start rabbitmq
-    - uses: actions/checkout@v2
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
+    - uses: actions/checkout@v4
+    - uses: ruby/setup-ruby@v1
       with:
         bundler-cache: true
         ruby-version: ${{ matrix.ruby }}

data/.github/workflows/release.yml

@@ -0,0 +1,26 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - v*
+  workflow_dispatch:
+
+jobs:
+  release:
+    if: github.repository == 'cloudamqp/amqp-client.rb'
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write # for trusted publishing
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: ruby
+      - uses: rubygems/configure-rubygems-credentials@v1.0.0
+      - run: ruby -v
+      # ensure gem can be built and installed, push to rubygems.org
+      - run: gem build *.gemspec
+      - run: gem install *.gem
+      - run: gem push *.gem

data/.rubocop.yml

@@ -1,7 +1,9 @@
 inherit_from: .rubocop_todo.yml
 
 AllCops:
+  NewCops: disable
   TargetRubyVersion: 2.6
+  SuggestExtensions: false
 
 Style/StringLiterals:
   Enabled: true

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [1.1.6] - 2024-03-26
+
+- Fixed: Channel#wait_for_confirms now waits for all confirms, in a thread safe way
+- Changed: When server sends Connection.blocked the client isn't write blocked anymore, and can continue consume for instance. However, the on_blocked/unblocked callbacks should be used and manually stop publishing as the server otherwise will stop reading from the client socket.
+
+## [1.1.5] - 2024-03-15
+
+- Fixed: Correctly reference the `UnexpectedFrameEnd` exception
+
 ## [1.1.4] - 2021-12-27
 
 - Fixed: Ruby 3.1.0 compability, StringIO have to be required manually

data/Gemfile

@@ -11,6 +11,8 @@ gem "minitest", "~> 5.0"
 
 gem "rubocop", "~> 1.7"
 
+gem "rubocop-minitest", require: false
+
 gem "yard", require: false
 
-gem "rubocop-minitest", require: false
+gem "redcarpet", require: false, platforms: :ruby

data/README.md

@@ -49,6 +49,10 @@ puts msg.body
 The library provides a high-level API that is a bit easier to get started with, and also handles reconnection automatically.
 
 ```ruby
+require "amqp-client"
+require "json"
+require "zlib"
+
 # 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
@@ -62,9 +66,10 @@ 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.
 myqueue.subscribe(prefetch: 20) do |msg|
-  process(JSON.parse(msg.body))
+  puts JSON.parse(msg.body)
   msg.ack
-rescue
+rescue => e
+  puts e.full_message
   msg.reject(requeue: false)
 end
 
@@ -76,16 +81,27 @@ amqp.publish("my message", "amq.topic", "topic.foo", headers: { foo: 'bar' })
 amqp.publish(Zlib.gzip("an event"), "amq.topic", "my.event", content_encoding: 'gzip')
 ```
 
+## Benchmark
+
+1 byte messages:
+
+| Client | Publish rate | Consume rate | Memory usage |
+| ------ | ------------ | ------------ | ------------ |
+| amqp-client.rb | 237.000 msgs/s | 154.000 msgs/s | 23 MB |
+| bunny | 39.000 msgs/s | 44.000 msgs/s | 31 MB |
+
+Gem comparison:
+
+| Client | Runtime dependencies | [Lines of code](https://github.com/AlDanial/cloc) |
+| --- | --- | --- |
+| amqp-client.rb | 0 | 1876 |
+| bunny | 2 | 4003 |
+
 ## Supported Ruby versions
 
 All maintained Ruby versions are supported.
 
-- 3.1
-- 3.0
-- 2.7
-- 2.6
-- jruby
-- truffleruby
+See the [CI workflow](https://github.com/cloudamqp/amqp-client.rb/blob/main/.github/workflows/main.yml) for the exact versions.
 
 ## Installation
 
@@ -107,7 +123,7 @@ Or install it yourself as:
 
 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.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the changelog and version number in `version.rb`, make a commit, and then run `bundle exec rake release:source_control_push`, which will create a git tag for the version, push git commits and the created tag. GitHub Actions will then push the `.gem` file to [rubygems.org](https://rubygems.org/gems/amqp-client).
 
 ## Contributing
 

data/Rakefile

@@ -22,4 +22,8 @@ RuboCop::RakeTask.new do |task|
   task.requires << "rubocop-minitest"
 end
 
+require "yard"
+
+YARD::Rake::YardocTask.new
+
 task default: [:test, *(:rubocop if RUBY_ENGINE == "ruby")]

data/amqp-client.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["carl@cloudamqp.com"]
 
   spec.summary       = "AMQP 0-9-1 client"
-  spec.description   = "Work in progress"
+  spec.description   = "Modern AMQP 0-9-1 Ruby client"
   spec.homepage      = "https://github.com/cloudamqp/amqp-client.rb"
   spec.license       = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
@@ -26,10 +26,4 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, checkout our
-  # guide at: https://bundler.io/guides/creating_gem.html
 end

data/lib/amqp/client/channel.rb

@@ -22,8 +22,9 @@ module AMQP
           @open = false
           @on_return = nil
           @confirm = nil
-          @unconfirmed = ::Queue.new
-          @unconfirmed_empty = ::Queue.new
+          @unconfirmed = []
+          @unconfirmed_lock = Mutex.new
+          @unconfirmed_empty = ConditionVariable.new
           @basic_gets = ::Queue.new
         end
 
@@ -60,7 +61,7 @@ module AMQP
           expect :channel_close_ok
           @replies.close
           @basic_gets.close
-          @unconfirmed_empty.close
+          @unconfirmed_lock.synchronize { @unconfirmed_empty.broadcast }
           @consumers.each_value(&:close)
           nil
         end
@@ -73,8 +74,9 @@ module AMQP
           @closed = [level, code, reason, classid, methodid]
           @replies.close
           @basic_gets.close
-          @unconfirmed_empty.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
           nil
         end
 
@@ -200,11 +202,12 @@ module AMQP
         # Purge a queue
         # @param name [String] Name of the queue
         # @param no_wait [Boolean] Don't wait for a broker confirmation if true
-        # @return [nil]
+        # @return [Integer] Number of messages in queue when purged
+        # @return [nil] If no_wait was set true
         def queue_purge(name, no_wait: false)
           write_bytes FrameBytes.queue_purge(@id, name, no_wait)
-          expect :queue_purge_ok unless no_wait
-          nil
+          message_count, = expect :queue_purge_ok unless no_wait
+          message_count
         end
 
         # Unbind a queue from an exchange
@@ -265,12 +268,15 @@ module AMQP
           when true then properties[:delivery_mode] = 2
           when false then properties[:delivery_mode] = 1
           end
-
+          if @confirm
+            @unconfirmed_lock.synchronize do
+              @unconfirmed.push @confirm += 1
+            end
+          end
           if body.bytesize.between?(1, body_max)
             write_bytes FrameBytes.basic_publish(id, exchange, routing_key, mandatory),
                         FrameBytes.header(id, body.bytesize, properties),
                         FrameBytes.body(id, body)
-            @unconfirmed.push @confirm += 1 if @confirm
             return
           end
 
@@ -283,7 +289,6 @@ module AMQP
             write_bytes FrameBytes.body(id, body_part)
             pos += len
           end
-          @unconfirmed.push @confirm += 1 if @confirm
           nil
         end
 
@@ -310,22 +315,16 @@ module AMQP
         # @yield [Message] Delivered message from the queue
         # @return [Array<(String, Array<Thread>)>] Returns consumer_tag and an array of worker threads
         # @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)
+        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)
-          q = @consumers[tag] = ::Queue.new
+          @consumers[tag] = q = ::Queue.new
           if worker_threads.zero?
-            loop do
-              yield (q.pop || break)
-            end
+            consume_loop(q, tag, &blk)
             nil
           else
             threads = Array.new(worker_threads) do
-              Thread.new do
-                loop do
-                  yield (q.pop || break)
-                end
-              end
+              Thread.new { consume_loop(q, tag, &blk) }
             end
             [tag, threads]
           end
@@ -400,42 +399,44 @@ module AMQP
         # @param no_wait [Boolean] If false the method will block until the broker has confirmed the request
         # @return [nil]
         def confirm_select(no_wait: false)
-          return if @confirm
+          return if @confirm # fast path
 
-          write_bytes FrameBytes.confirm_select(@id, no_wait)
-          expect :confirm_select_ok unless no_wait
-          @confirm = 0
+          @unconfirmed_lock.synchronize do
+            # check again in case another thread already did this while we waited for the lock
+            return if @confirm
+
+            write_bytes FrameBytes.confirm_select(@id, no_wait)
+            expect :confirm_select_ok unless no_wait
+            @confirm = 0
+          end
           nil
         end
 
         # Block until all publishes messages are confirmed
-        # @return [Boolean] True if all message where positivly acknowledged, false if not
+        # @return nil
         def wait_for_confirms
-          return true if @unconfirmed.empty?
-
-          ok = @unconfirmed_empty.pop
-          raise Error::Closed.new(@id, *@closed) if ok.nil?
-
-          ok
+          @unconfirmed_lock.synchronize do
+            until @unconfirmed.empty?
+              @unconfirmed_empty.wait(@unconfirmed_lock)
+              raise Error::Closed.new(@id, *@closed) if @closed
+            end
+          end
         end
 
         # Called by Connection when received ack/nack from broker
         # @api private
         def confirm(args)
-          ack_or_nack, delivery_tag, multiple = *args
-          loop do
-            tag = @unconfirmed.pop(true)
-            break if tag == delivery_tag
-            next if multiple && tag < delivery_tag
-
-            @unconfirmed << tag # requeue
-          rescue ThreadError
-            break
+          _ack_or_nack, delivery_tag, multiple = *args
+          @unconfirmed_lock.synchronize do
+            case multiple
+            when true
+              idx = @unconfirmed.index(delivery_tag) || raise("Delivery tag not found")
+              @unconfirmed.shift(idx + 1)
+            when false
+              @unconfirmed.delete(delivery_tag) || raise("Delivery tag not found")
+            end
+            @unconfirmed_empty.broadcast if @unconfirmed.empty?
           end
-          return unless @unconfirmed.empty?
-
-          ok = ack_or_nack == :ack
-          @unconfirmed_empty.push(ok) until @unconfirmed_empty.num_waiting.zero?
         end
 
         # @!endgroup
@@ -547,6 +548,21 @@ module AMQP
 
           args
         end
+
+        def consume_loop(queue, tag)
+          while (msg = queue.pop)
+            begin
+              yield msg
+            rescue StandardError # cancel the consumer if an uncaught exception is raised
+              begin
+                close("Unexpected exception in consumer #{tag} thread", 500)
+              rescue StandardError # ignore sockets errors while canceling
+                nil
+              end
+              raise # reraise original exception
+            end
+          end
+        end
       end
     end
   end

data/lib/amqp/client/connection.rb

@@ -48,9 +48,22 @@ module AMQP
         @replies = ::Queue.new
         @write_lock = Mutex.new
         @blocked = nil
+        @on_blocked = ->(reason) { warn "AMQP-Client blocked by broker: #{reason}" }
+        @on_unblocked = -> { warn "AMQP-Client unblocked by broker" }
+
         Thread.new { read_loop } if read_loop_thread
       end
 
+      # Indicates that the server is blocking publishes.
+      # If the client keeps publishing the server will stop reading from the socket.
+      # Use the #on_blocked callback to get notified when the server is resource constrained.
+      # @see #on_blocked
+      # @see #on_unblocked
+      # @return [Bool]
+      def blocked?
+        !@blocked.nil?
+      end
+
       # Alias for {#initialize}
       # @see #initialize
       # @deprecated
@@ -125,20 +138,33 @@ module AMQP
         !@closed.nil?
       end
 
+      # @!group Callbacks
+
+      # Callback called when client is blocked by the broker
+      # @yield [String] reason to why the connection is being blocked
+      # @return [nil]
+      def on_blocked(&blk)
+        @on_blocked = blk
+        nil
+      end
+
+      # Callback called when client is unblocked by the broker
+      # @yield
+      # @return [nil]
+      def on_unblocked(&blk)
+        @on_unblocked = blk
+        nil
+      end
+
+      # @!endgroup
+
       # Write byte array(s) directly to the socket (thread-safe)
       # @param bytes [String] One or more byte arrays
       # @return [Integer] number of bytes written
       # @api private
       def write_bytes(*bytes)
-        blocked = @blocked
-        warn "AMQP-Client blocked by broker: #{blocked}" if blocked
         @write_lock.synchronize do
-          warn "AMQP-Client unblocked by broker" if blocked
-          if RUBY_ENGINE == "truffleruby"
-            bytes.each { |b| @socket.write b }
-          else
-            @socket.write(*bytes)
-          end
+          @socket.write(*bytes)
         end
       rescue *READ_EXCEPTIONS => e
         raise Error::ConnectionClosed.new(*@closed) if @closed
@@ -166,7 +192,7 @@ module AMQP
 
           # make sure that the frame end is correct
           frame_end = socket.readchar.ord
-          raise UnexpectedFrameEnd, frame_end if frame_end != 206
+          raise Error::UnexpectedFrameEnd, 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
@@ -179,8 +205,12 @@ module AMQP
         @closed ||= [400, "unknown"]
         @replies.close
         begin
-          @write_lock.synchronize do
+          if @write_lock.owned? # if connection is blocked
             @socket.close
+          else
+            @write_lock.synchronize do
+              @socket.close
+            end
           end
         rescue *READ_EXCEPTIONS
           nil
@@ -192,7 +222,8 @@ module AMQP
       READ_EXCEPTIONS = [IOError, OpenSSL::OpenSSLError, SystemCallError,
                          RUBY_ENGINE == "jruby" ? java.lang.NullPointerException : nil].compact.freeze
 
-      def parse_frame(type, channel_id, buf)
+      def parse_frame(type, channel_id, buf) # rubocop:disable Metrics/MethodLength
+        channel = @channels[channel_id]
         case type
         when 1 # method frame
           class_id, method_id = buf.unpack("S> S>")
@@ -220,16 +251,16 @@ module AMQP
               reason_len = buf.getbyte(4)
               reason = buf.byteslice(5, reason_len).force_encoding("utf-8")
               @blocked = reason
-              @write_lock.lock
+              @on_blocked.call(reason)
             when 61 # connection#unblocked
               @blocked = nil
-              @write_lock.unlock
+              @on_unblocked.call
             else raise Error::UnsupportedMethodFrame, class_id, method_id
             end
           when 20 # channel
             case method_id
             when 11 # channel#open-ok
-              @channels[channel_id].reply [:channel_open_ok]
+              channel.reply [:channel_open_ok]
             when 40 # channel#close
               reply_code, reply_text_len = buf.unpack("@4 S> C")
               reply_text = buf.byteslice(7, reply_text_len).force_encoding("utf-8")
@@ -245,13 +276,13 @@ module AMQP
           when 40 # exchange
             case method_id
             when 11 # declare-ok
-              @channels[channel_id].reply [:exchange_declare_ok]
+              channel.reply [:exchange_declare_ok]
             when 21 # delete-ok
-              @channels[channel_id].reply [:exchange_delete_ok]
+              channel.reply [:exchange_delete_ok]
             when 31 # bind-ok
-              @channels[channel_id].reply [:exchange_bind_ok]
+              channel.reply [:exchange_bind_ok]
             when 51 # unbind-ok
-              @channels[channel_id].reply [:exchange_unbind_ok]
+              channel.reply [:exchange_unbind_ok]
             else raise Error::UnsupportedMethodFrame, class_id, method_id
             end
           when 50 # queue
@@ -260,36 +291,37 @@ module AMQP
               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]
+              channel.reply [:queue_declare_ok, queue_name, message_count, consumer_count]
             when 21 # bind-ok
-              @channels[channel_id].reply [:queue_bind_ok]
+              channel.reply [:queue_bind_ok]
             when 31 # purge-ok
-              @channels[channel_id].reply [:queue_purge_ok]
+              message_count = buf.unpack1("@4 L>")
+              channel.reply [:queue_purge_ok, message_count]
             when 41 # delete-ok
               message_count = buf.unpack1("@4 L>")
-              @channels[channel_id].reply [:queue_delete, message_count]
+              channel.reply [:queue_delete, message_count]
             when 51 # unbind-ok
-              @channels[channel_id].reply [:queue_unbind_ok]
+              channel.reply [:queue_unbind_ok]
             else raise Error::UnsupportedMethodFrame.new class_id, method_id
             end
           when 60 # basic
             case method_id
             when 11 # qos-ok
-              @channels[channel_id].reply [:basic_qos_ok]
+              channel.reply [:basic_qos_ok]
             when 21 # consume-ok
               tag_len = buf.getbyte(4)
               tag = buf.byteslice(5, tag_len).force_encoding("utf-8")
-              @channels[channel_id].reply [:basic_consume_ok, tag]
+              channel.reply [:basic_consume_ok, tag]
             when 30 # cancel
               tag_len = buf.getbyte(4)
               tag = buf.byteslice(5, tag_len).force_encoding("utf-8")
               no_wait = buf.getbyte(5 + tag_len) == 1
-              @channels[channel_id].close_consumer(tag)
+              channel.close_consumer(tag)
               write_bytes FrameBytes.basic_cancel_ok(@id, tag) unless no_wait
             when 31 # cancel-ok
               tag_len = buf.getbyte(4)
               tag = buf.byteslice(5, tag_len).force_encoding("utf-8")
-              @channels[channel_id].reply [:basic_cancel_ok, tag]
+              channel.reply [:basic_cancel_ok, tag]
             when 50 # return
               reply_code, reply_text_len = buf.unpack("@4 S> C")
               pos = 7
@@ -302,7 +334,7 @@ module AMQP
               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)
+              channel.message_returned(reply_code, reply_text, exchange, routing_key)
             when 60 # deliver
               ctag_len = buf.getbyte(4)
               consumer_tag = buf.byteslice(5, ctag_len).force_encoding("utf-8")
@@ -314,7 +346,7 @@ module AMQP
               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)
+              channel.message_delivered(consumer_tag, delivery_tag, redelivered == 1, exchange, routing_key)
             when 71 # get-ok
               delivery_tag, redelivered, exchange_len = buf.unpack("@4 Q> C C")
               pos = 14
@@ -325,33 +357,33 @@ module AMQP
               routing_key = buf.byteslice(pos, routing_key_len).force_encoding("utf-8")
               # 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)
+              channel.message_delivered(nil, delivery_tag, redelivered == 1, exchange, routing_key)
             when 72 # get-empty
-              @channels[channel_id].basic_get_empty
+              channel.basic_get_empty
             when 80 # ack
               delivery_tag, multiple = buf.unpack("@4 Q> C")
-              @channels[channel_id].confirm [:ack, delivery_tag, multiple == 1]
+              channel.confirm [:ack, delivery_tag, multiple == 1]
             when 111 # recover-ok
-              @channels[channel_id].reply [:basic_recover_ok]
+              channel.reply [:basic_recover_ok]
             when 120 # nack
               delivery_tag, multiple, requeue = buf.unpack("@4 Q> C C")
-              @channels[channel_id].confirm [:nack, delivery_tag, multiple == 1, requeue == 1]
+              channel.confirm [:nack, delivery_tag, multiple == 1, requeue == 1]
             else raise Error::UnsupportedMethodFrame.new class_id, method_id
             end
           when 85 # confirm
             case method_id
             when 11 # select-ok
-              @channels[channel_id].reply [:confirm_select_ok]
+              channel.reply [:confirm_select_ok]
             else raise Error::UnsupportedMethodFrame.new class_id, method_id
             end
           when 90 # tx
             case method_id
             when 11 # select-ok
-              @channels[channel_id].reply [:tx_select_ok]
+              channel.reply [:tx_select_ok]
             when 21 # commit-ok
-              @channels[channel_id].reply [:tx_commit_ok]
+              channel.reply [:tx_commit_ok]
             when 31 # rollback-ok
-              @channels[channel_id].reply [:tx_rollback_ok]
+              channel.reply [:tx_rollback_ok]
             else raise Error::UnsupportedMethodFrame.new class_id, method_id
             end
           else raise Error::UnsupportedMethodFrame.new class_id, method_id
@@ -359,9 +391,9 @@ module AMQP
         when 2 # header
           body_size = buf.unpack1("@4 Q>")
           properties = Properties.decode(buf, 12)
-          @channels[channel_id].header_delivered body_size, properties
+          channel.header_delivered body_size, properties
         when 3 # body
-          @channels[channel_id].body_delivered buf
+          channel.body_delivered buf
         else raise Error::UnsupportedFrameType, type
         end
         true
@@ -419,7 +451,7 @@ module AMQP
 
           type, channel_id, frame_size = buf.unpack("C S> L>")
           frame_end = buf.getbyte(frame_size + 7)
-          raise UnexpectedFrameEndError, frame_end if frame_end != 206
+          raise Error::UnexpectedFrameEnd, frame_end if frame_end != 206
 
           case type
           when 1 # method frame

data/lib/amqp/client/version.rb

@@ -3,6 +3,6 @@
 module AMQP
   class Client
     # Version of the client library
-    VERSION = "1.1.4"
+    VERSION = "1.1.6"
   end
 end

data/lib/amqp/client.rb

@@ -26,7 +26,6 @@ module AMQP
     def initialize(uri = "", **options)
       @uri = uri
       @options = options
-
       @queues = {}
       @exchanges = {}
       @subscriptions = Set.new
@@ -172,15 +171,16 @@ module AMQP
 
     # Consume messages from a queue
     # @param queue [String] Name of the queue to subscribe to
-    # @param no_ack [Boolean] When false messages have to be manually acknowledged (or rejected)
-    # @param prefetch [Integer] Specify how many messages to prefetch for consumers with no_ack is false
-    # @param worker_threads [Integer] Number of threads processing messages,
-    #   0 means that the thread calling this method will be blocked
+    # @param no_ack [Boolean] When false messages have to be manually acknowledged (or rejected) (default: false)
+    # @param prefetch [Integer] Specify how many messages to prefetch for consumers with no_ack is false (default: 1)
+    # @param worker_threads [Integer] Number of threads processing messages (default: 1)
     # @param arguments [Hash] Custom arguments to the consumer
     # @yield [Message] Delivered message from the queue
     # @return [Array<(String, Array<Thread>)>] Returns consumer_tag and an array of worker threads
-    # @return [nil] When `worker_threads` is 0 the method will return when the consumer is cancelled
+    # @return [nil]
     def subscribe(queue, no_ack: false, prefetch: 1, worker_threads: 1, arguments: {}, &blk)
+      raise ArgumentError, "worker_threads have to be > 0" if worker_threads <= 0
+
       @subscriptions.add? [queue, no_ack, prefetch, worker_threads, arguments, blk]
 
       with_connection do |conn|

metadata

@@ -1,24 +1,26 @@
 --- !ruby/object:Gem::Specification
 name: amqp-client
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.1.6
 platform: ruby
 authors:
 - Carl Hörberg
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-27 00:00:00.000000000 Z
+date: 2024-03-26 00:00:00.000000000 Z
 dependencies: []
-description: Work in progress
+description: Modern AMQP 0-9-1 Ruby client
 email:
 - carl@cloudamqp.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/codeql-analysis.yml"
 - ".github/workflows/docs.yml"
 - ".github/workflows/main.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
@@ -43,7 +45,6 @@ files:
 - lib/amqp/client/queue.rb
 - lib/amqp/client/table.rb
 - lib/amqp/client/version.rb
-- sig/amqp-client.rbs
 homepage: https://github.com/cloudamqp/amqp-client.rb
 licenses:
 - MIT
@@ -51,7 +52,7 @@ metadata:
   homepage_uri: https://github.com/cloudamqp/amqp-client.rb
   source_code_uri: https://github.com/cloudamqp/amqp-client.rb.git
   changelog_uri: https://github.com/cloudamqp/amqp-client.rb/blob/main/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -66,8 +67,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
-signing_key:
+rubygems_version: 3.5.3
+signing_key: 
 specification_version: 4
 summary: AMQP 0-9-1 client
 test_files: []

data/sig/amqp-client.rbs

@@ -1,264 +0,0 @@
-# TypeProf 0.15.3
-
-# Classes
-module AMQP
-  class Client
-    VERSION: String
-    @uri: String
-    @options: Hash[Symbol, (String | Integer | bool)]
-    @queues: Hash[String, Queue]
-    @exchanges: Hash[String, Exchange]
-    @subscriptions: Set[[String, bool, Integer, Integer, Hash[Symbol, untyped], nil]]
-    @connq: Thread::SizedQueue
-    @stopped: bool
-
-    def initialize: (?String uri, **untyped) -> void
-    def connect: (?read_loop_thread: bool) -> Connection
-    def start: -> Client
-    def stop: -> nil
-    def queue: (String name, ?durable: bool, ?auto_delete: bool, ?arguments: Hash[Symbol | String, (String | Integer | bool)]) -> Queue
-    def exchange: (String name, String `type`, ?durable: bool, ?auto_delete: bool, ?internal: bool, ?arguments: Hash[Symbol | String, untyped]) -> Exchange
-    def publish: (String body, String exchange, String routing_key, **untyped) -> bool
-    def publish_and_forget: (String body, String exchange, String routing_key, **untyped) -> nil
-    def wait_for_confirms: -> bool
-    def subscribe: (String queue, ?no_ack: bool, ?prefetch: Integer, ?worker_threads: Integer, ?arguments: Hash[Symbol | String, untyped]) { (Message) -> void } -> [String, Array[Thread]]?
-    def bind: (String queue, String exchange, String binding_key, ?arguments: Hash[Symbol | String, untyped]) -> nil
-    def unbind: (String queue, String exchange, String binding_key, ?arguments: Hash[Symbol | String, untyped]) -> nil
-    def purge: (String queue) -> nil
-    def delete_queue: (String name, ?if_unused: bool, ?if_empty: bool) -> Integer?
-    def exchange_bind: (String destination, String source, String binding_key, ?arguments: Hash[Symbol | String, untyped]) -> nil
-    def exchange_unbind: (String destination, String source, String binding_key, ?arguments: Hash[Symbol | String, untyped]) -> nil
-    def delete_exchange: (String name) -> nil
-    def with_connection: { (Connection) -> void } -> void
-
-    module Table
-      def self.encode: (Hash[Symbol | String, untyped] hash) -> String
-      def self.decode: (String bytes) -> Hash[String, untyped]
-    end
-
-    class Properties
-      attr_accessor content_type(): String?
-      attr_accessor content_encoding(): String?
-      attr_accessor headers(): Hash[String | Symbol, untyped]?
-      attr_accessor delivery_mode(): Integer?
-      attr_accessor priority(): Integer?
-      attr_accessor correlation_id(): String?
-      attr_accessor reply_to(): String?
-      attr_accessor expiration(): (Integer | String)?
-      attr_accessor message_id(): String?
-      attr_accessor timestamp(): Time?
-      attr_accessor type(): String?
-      attr_accessor user_id(): String?
-      attr_accessor app_id(): String?
-    end
-
-    module FrameBytes
-      def self.connection_start_ok: (String response, Hash[untyped, untyped] properties) -> String
-      def self.connection_tune_ok: ((Float | Integer | String)? channel_max, (Float | Integer | String)? frame_max, (Float | Integer | String)? heartbeat) -> String
-      def self.connection_open: (String vhost) -> String
-      def self.connection_close: (Integer code, String reason) -> String
-      def self.connection_close_ok: -> String
-      def self.channel_open: (Integer id) -> String
-      def self.channel_close: (Integer id, String reason, Integer code) -> String
-      def self.channel_close_ok: ((Float | Integer | String)? id) -> String
-      def self.exchange_declare: (Integer id, untyped name, untyped `type`, bool passive, bool durable, bool auto_delete, bool internal, Hash[untyped, untyped] arguments) -> String
-      def self.exchange_delete: (Integer id, untyped name, bool if_unused, bool no_wait) -> String
-      def self.exchange_bind: (Integer id, untyped destination, untyped source, untyped binding_key, bool no_wait, Hash[untyped, untyped] arguments) -> String
-      def self.exchange_unbind: (Integer id, untyped destination, untyped source, untyped binding_key, bool no_wait, Hash[untyped, untyped] arguments) -> String
-      def self.queue_declare: (Integer id, String name, bool passive, bool durable, bool exclusive, bool auto_delete, Hash[untyped, untyped] arguments) -> String
-      def self.queue_delete: (Integer id, untyped name, bool if_unused, bool if_empty, bool no_wait) -> String
-      def self.queue_bind: (Integer id, untyped queue, untyped exchange, untyped binding_key, bool no_wait, Hash[untyped, untyped] arguments) -> String
-      def self.queue_unbind: (Integer id, untyped queue, untyped exchange, untyped binding_key, Hash[untyped, untyped] arguments) -> String
-      def self.queue_purge: (Integer id, untyped queue, bool no_wait) -> String
-      def self.basic_get: (Integer id, untyped queue, bool no_ack) -> String
-      def self.basic_publish: (Integer id, untyped exchange, untyped routing_key, bool mandatory) -> String
-      def self.header: (Integer id, untyped body_size, Hash[(Symbol | String), untyped] properties) -> String
-      def self.body: (Integer id, untyped body_part) -> String
-      def self.basic_consume: (Integer id, String queue, String? tag, bool? no_ack, bool? exclusive, Hash[untyped, untyped]? arguments) -> String
-      def self.basic_cancel: (Integer id, untyped consumer_tag, ?no_wait: bool) -> String
-      def self.basic_cancel_ok: (Integer id, String consumer_tag) -> String
-      def self.basic_ack: (Integer id, untyped delivery_tag, bool multiple) -> String
-      def self.basic_nack: (Integer id, untyped delivery_tag, bool multiple, bool requeue) -> String
-      def self.basic_reject: (Integer id, untyped delivery_tag, bool requeue) -> String
-      def self.basic_qos: (Integer id, Integer? prefetch_size, Integer? prefetch_count, bool? global) -> String
-      def self.basic_recover: (Integer id, untyped requeue) -> String
-      def self.confirm_select: (Integer id, bool no_wait) -> String
-      def self.tx_select: (Integer id) -> String
-      def self.tx_commit: (Integer id) -> String
-      def self.tx_rollback: (Integer id) -> String
-    end
-
-    class Message
-      attr_reader channel(): Connection::Channel
-      attr_reader delivery_tag(): Integer
-      attr_reader exchange(): String
-      attr_reader routing_key(): String
-      attr_reader redelivered(): bool
-      attr_reader consumer_tag(): String?
-      attr_accessor properties(): Properties
-      attr_accessor body(): String
-    end
-
-    class ReturnMessage
-      attr_reader reply_code(): Integer
-      attr_reader reply_text(): String
-      attr_reader exchange(): String
-      attr_reader routing_key(): String
-      attr_accessor properties(): Properties
-      attr_accessor body(): String
-    end
-
-    class Connection
-      CLIENT_PROPERTIES: Hash[Symbol | String, untyped]
-      @socket: (IO | untyped)
-      @channel_max: Integer
-      @heartbeat: Integer
-      @channels: Hash[Integer, Channel]
-      @closed: Array[untyped]?
-      @replies: Thread::Queue
-      @write_lock: Thread::Mutex
-      @blocked: String?
-      @id: Integer
-
-      def initialize: (?String uri, ?read_loop_thread: bool, **untyped) -> void
-      def self.connect: (?String uri, ?read_loop_thread: bool, **untyped) -> Connection
-      attr_reader frame_max: Integer
-      def inspect: -> String
-      def channel: (?Integer? id) -> Channel
-      def with_channel: { (Channel) -> void } -> void
-      def close: (?reason: String, ?code: Integer) -> nil
-      def closed?: -> bool
-      def write_bytes: (*String bytes) -> Integer
-      def read_loop: -> nil
-
-      private
-      def parse_frame: (Integer `type`, Integer channel_id, String buf) -> bool
-      def expect: (:close_ok expected_frame_type) -> untyped
-      def open_socket: (String host, Integer port, bool tls, Hash[Symbol, untyped] options) -> (IO | untyped)
-      def establish: ((IO | untyped) socket, String user, String password, String vhost, Hash[Symbol, untyped] options) -> [Integer, Integer, Integer]
-      def enable_tcp_keepalive: ((IO | untyped) socket) -> void
-      def port_from_env: -> Integer?
-
-      class Channel
-        @connection: Connection
-        @replies: Thread::Queue
-        @consumers: Hash[String, Thread::Queue]
-        @closed: Array[(:channel | :connection | Integer | String)]?
-        @open: bool
-        @on_return: nil
-        @confirm: Integer?
-        @unconfirmed: Thread::Queue
-        @unconfirmed_empty: Thread::Queue
-        @basic_gets: Thread::Queue
-        @next_msg: (Message | ReturnMessage)?
-        @next_body: StringIO?
-        @next_body_size: (Float | Integer | String)?
-
-        def initialize: (Connection connection, Integer? id) -> void
-        def inspect: -> String
-        attr_reader id: Integer?
-        def open: -> Channel
-        def close: (?reason: String, ?code: Integer) -> nil
-        def closed!: (:channel | :connection level, (Float | Integer | String)? code, String reason, (Float | Integer | String)? classid, (Float | Integer | String)? methodid) -> nil
-        def on_return: { (ReturnMessage) -> void } -> void
-        def exchange_declare: (String name, String `type`, ?passive: bool, ?durable: bool, ?auto_delete: bool, ?internal: bool, ?arguments: Hash[untyped, untyped]) -> nil
-        def exchange_delete: (String name, ?if_unused: bool, ?no_wait: bool) -> nil
-        def exchange_bind: (String destination, String source, String binding_key, ?arguments: Hash[untyped, untyped]) -> nil
-        def exchange_unbind: (String destination, String source, String binding_key, ?arguments: Hash[untyped, untyped]) -> nil
-        def queue_declare: (?String name, ?passive: bool, ?durable: bool, ?exclusive: bool, ?auto_delete: bool, ?arguments: Hash[untyped, untyped]) -> QueueOk
-        def queue_delete: (String name, ?if_unused: bool, ?if_empty: bool, ?no_wait: bool) -> Integer?
-        def queue_bind: (String name, String exchange, String binding_key, ?arguments: Hash[untyped, untyped]) -> nil
-        def queue_purge: (String name, ?no_wait: bool) -> nil
-        def queue_unbind: (String name, String exchange, String binding_key, ?arguments: Hash[untyped, untyped]) -> nil
-        def basic_get: (String queue_name, ?no_ack: bool) -> Message?
-        def basic_publish: (String body, String exchange, String routing_key, **untyped) -> nil
-        def basic_publish_confirm: (String body, String exchange, String routing_key, **untyped) -> bool
-        def basic_consume: (String queue, ?tag: String, ?no_ack: bool?, ?exclusive: bool, ?arguments: Hash[untyped, untyped]?, ?worker_threads: Integer?) { (Message) -> void } -> [String, Array[Thread]]?
-        def basic_cancel: (String consumer_tag, ?no_wait: bool) -> nil
-        def basic_qos: (Integer prefetch_count, ?prefetch_size: Integer, ?global: bool) -> nil
-        def basic_ack: (Integer delivery_tag, ?multiple: bool) -> nil
-        def basic_nack: (Integer delivery_tag, ?multiple: bool, ?requeue: bool) -> nil
-        def basic_reject: (Integer delivery_tag, ?requeue: bool) -> nil
-        def basic_recover: (?requeue: bool) -> nil
-        def confirm_select: (?no_wait: bool) -> nil
-        def wait_for_confirms: -> bool
-        def tx_select: -> nil
-        def tx_commit: -> nil
-        def tx_rollback: -> nil
-        def reply: (Array[untyped] args) -> void
-        def confirm: (Array[(:ack | :nack | Integer | bool)] args) -> nil
-        def message_returned: ((Float | Integer | String)? reply_code, String reply_text, String exchange, String routing_key) -> ReturnMessage
-        def message_delivered: (String? consumer_tag, (Float | Integer | String)? delivery_tag, bool redelivered, String exchange, String routing_key) -> Message
-        def basic_get_empty: -> void
-        def header_delivered: (Integer body_size, Properties properties) -> void
-        def body_delivered: (String body_part) -> void
-        def close_consumer: (String tag) -> nil
-
-        private
-        def next_message_finished!: -> void
-        def write_bytes: (*String bytes) -> Integer
-        def expect: (Symbol expected_frame_type) -> Array[untyped]
-
-        class QueueOk < Struct[untyped]
-          attr_accessor queue_name(): String
-          attr_accessor message_count(): Integer
-          attr_accessor consumer_count(): Integer
-        end
-      end
-    end
-
-    class Error < StandardError
-      class UnexpectedFrame < Error
-        def initialize: (Symbol expected, Symbol actual) -> void
-      end
-
-      class UnexpectedFrameEnd < Error
-        def initialize: (untyped actual) -> void
-      end
-
-      class UnsupportedFrameType < Error
-        def initialize: (untyped `type`) -> void
-      end
-
-      class UnsupportedMethodFrame < Error
-        def initialize: (Integer class_id, Integer method_id) -> void
-      end
-
-      class Closed < Error
-        def self.new: (Integer id, (:channel | :connection) level, Integer code, String reason, ?Integer classid, ?Integer methodid) -> (ChannelClosed | ConnectionClosed)
-      end
-
-      class ChannelClosed < Error
-        def initialize: (Integer id, Integer code, String reason, ?Integer classid, ?Integer methodid) -> void
-      end
-
-      class ConnectionClosed < Error
-        def initialize: (Integer code, String reason, ?Integer classid, ?Integer methodid) -> void
-      end
-    end
-
-    class Exchange
-      @client: Client
-      @name: String
-
-      def initialize: (Client client, String name) -> void
-      def publish: (String body, String routing_key, **untyped) -> Exchange
-      def bind: (String exchange, String binding_key, ?arguments: Hash[String | Symbol, untyped]) -> Exchange
-      def unbind: (String exchange, String binding_key, ?arguments: Hash[String | Symbol, untyped]) -> Exchange
-      def delete: -> nil
-    end
-
-    class Queue
-      @client: Client
-      @name: String
-
-      def initialize: (Client client, String name) -> void
-      def publish: (String body, **untyped) -> Queue
-      def subscribe: (?no_ack: bool, ?prefetch: Integer, ?worker_threads: Integer, ?arguments: Hash[String | Symbol, untyped]) { (Message) -> void } -> Queue
-      def bind: (String exchange, String binding_key, ?arguments: Hash[String | Symbol, untyped]) -> Queue
-      def unbind: (String exchange, String binding_key, ?arguments: Hash[String | Symbol, untyped]) -> Queue
-      def purge: -> Queue
-      def delete: -> nil
-    end
-  end
-end