amqp-client 1.0.1 → 1.1.2

data/lib/amqp/client.rb

@@ -23,7 +23,7 @@ module AMQP
     #    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.
-    def initialize(uri, **options)
+    def initialize(uri = "", **options)
       @uri = uri
       @options = options
 
@@ -35,15 +35,21 @@ module AMQP
 
     # @!group Connect and disconnect
 
-    # Establishes a new AMQP connection, does not try to reconnect
-    # @see Connection.connect
+    # Establishes and returns a new AMQP connection
+    # @see Connection#initialize
     # @return [Connection]
+    # @example
+    #   connection = AMQP::Client.new("amqps://server.rmq.cloudamqp.com", connection_name: "My connection").connect
     def connect(read_loop_thread: true)
-      Connection.connect(@uri, read_loop_thread: read_loop_thread, **@options)
+      Connection.new(@uri, read_loop_thread: read_loop_thread, **@options)
     end
 
     # Opens an AMQP connection using the high level API, will try to reconnect if successfully connected at first
     # @return [self]
+    # @example
+    #   amqp = AMQP::Client.new("amqps://server.rmq.cloudamqp.com")
+    #   amqp.start
+    #   amqp.queue("foobar")
     def start
       @stopped = false
       Thread.new(connect(read_loop_thread: false)) do |conn|
@@ -95,6 +101,10 @@ module AMQP
     #   (it won't be deleted until at least one consumer has consumed from it)
     # @param arguments [Hash] Custom arguments, such as queue-ttl etc.
     # @return [Queue]
+    # @example
+    #   amqp = AMQP::Client.new.start
+    #   q = amqp.queue("foobar")
+    #   q.publish("body")
     def queue(name, durable: true, auto_delete: false, arguments: {})
       raise ArgumentError, "Currently only supports named, durable queues" if name.empty?
 
@@ -108,6 +118,10 @@ module AMQP
 
     # Declare an exchange and return a high level Exchange object
     # @return [Exchange]
+    # @example
+    #   amqp = AMQP::Client.new.start
+    #   x = amqp.exchange("my.hash.exchange", "x-consistent-hash")
+    #   x.publish("body", "routing-key")
     def exchange(name, type, durable: true, auto_delete: false, internal: false, arguments: {})
       @exchanges.fetch(name) do
         with_connection do |conn|
@@ -122,7 +136,10 @@ module AMQP
     # @!group Publish
 
     # Publish a (persistent) message and wait for confirmation
-    # @return [nil]
+    # @param (see Connection::Channel#basic_publish_confirm)
+    # @option (see Connection::Channel#basic_publish_confirm)
+    # @return (see Connection::Channel#basic_publish_confirm)
+    # @raise (see Connection::Channel#basic_publish_confirm)
     def publish(body, exchange, routing_key, **properties)
       with_connection do |conn|
         properties = { delivery_mode: 2 }.merge!(properties)
@@ -131,7 +148,10 @@ module AMQP
     end
 
     # Publish a (persistent) message but don't wait for a confirmation
-    # @return [nil]
+    # @param (see Connection::Channel#basic_publish)
+    # @option (see Connection::Channel#basic_publish)
+    # @return (see Connection::Channel#basic_publish)
+    # @raise (see Connection::Channel#basic_publish)
     def publish_and_forget(body, exchange, routing_key, **properties)
       with_connection do |conn|
         properties = { delivery_mode: 2 }.merge!(properties)
@@ -166,9 +186,7 @@ module AMQP
       with_connection do |conn|
         ch = conn.channel
         ch.basic_qos(prefetch)
-        ch.basic_consume(queue, no_ack: no_ack, worker_threads: worker_threads, arguments: arguments) do |msg|
-          blk.call(msg)
-        end
+        ch.basic_consume(queue, no_ack: no_ack, worker_threads: worker_threads, arguments: arguments, &blk)
       end
     end
 

data/sig/amqp-client.rbs

@@ -0,0 +1,264 @@
+# 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: amqp-client
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Carl Hörberg
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-06 00:00:00.000000000 Z
+date: 2021-10-15 00:00:00.000000000 Z
 dependencies: []
 description: Work in progress
 email:
@@ -37,12 +37,13 @@ files:
 - lib/amqp/client/connection.rb
 - lib/amqp/client/errors.rb
 - lib/amqp/client/exchange.rb
-- lib/amqp/client/frames.rb
+- lib/amqp/client/frame_bytes.rb
 - lib/amqp/client/message.rb
 - lib/amqp/client/properties.rb
 - 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
@@ -58,7 +59,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="