amqp-client 1.0.1 → 1.1.2

data/lib/amqp/client/properties.rb

@@ -5,44 +5,111 @@ require_relative "./table"
 module AMQP
   class Client
     # Encode/decode AMQP Properties
-    # @!attribute content_type
-    #   @return [String] Content type of the message body
-    # @!attribute content_encoding
-    #   @return [String] Content encoding of the body
-    # @!attribute headers
-    #   @return [Hash<String, Object>] Custom headers
-    # @!attribute delivery_mode
-    #   @return [Integer] 2 for persisted message, transient messages for all other values
-    # @!attribute priority
-    #   @return [Integer] A priority of the message (between 0 and 255)
-    # @!attribute correlation_id
-    #   @return [Integer] A correlation id, most often used used for RPC communication
-    # @!attribute reply_to
-    #   @return [String] Queue to reply RPC responses to
-    # @!attribute expiration
-    #   @return [Integer, String] Number of seconds the message will stay in the queue
-    # @!attribute message_id
-    #   @return [String]
-    # @!attribute timestamp
-    #   @return [Date] User-definable, but often used for the time the message was originally generated
-    # @!attribute type
-    #   @return [String] User-definable, but can can indicate what kind of message this is
-    # @!attribute user_id
-    #   @return [String] User-definable, but can be used to verify that this is the user that published the message
-    # @!attribute app_id
-    #   @return [String] User-definable, but often indicates which app that generated the message
-    Properties = Struct.new(:content_type, :content_encoding, :headers, :delivery_mode, :priority, :correlation_id,
-                            :reply_to, :expiration, :message_id, :timestamp, :type, :user_id, :app_id,
-                            keyword_init: true) do
+    class Properties
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(content_type: nil, content_encoding: nil, headers: nil, delivery_mode: nil,
+                     priority: nil, correlation_id: nil, reply_to: nil, expiration: nil,
+                     message_id: nil, timestamp: nil, type: nil, user_id: nil, app_id: nil)
+        @content_type = content_type
+        @content_encoding = content_encoding
+        @headers = headers
+        @delivery_mode = delivery_mode
+        @priority = priority
+        @correlation_id = correlation_id
+        @reply_to = reply_to
+        @expiration = expiration
+        @message_id = message_id
+        @timestamp = timestamp
+        @type = type
+        @user_id = user_id
+        @app_id = app_id
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Properties as a Hash
+      # @return [Hash] Properties
+      def to_h
+        {
+          content_type: content_type,
+          content_encoding: content_encoding,
+          headers: headers,
+          delivery_mode: delivery_mode,
+          priority: priority,
+          correlation_id: correlation_id,
+          reply_to: reply_to,
+          expiration: expiration,
+          message_id: message_id,
+          timestamp: timestamp,
+          type: type,
+          user_id: user_id,
+          app_id: app_id
+        }
+      end
+
+      alias to_hash to_h
+
+      # Returns true if two Property objects holds the same information
+      # @return [Boolean]
+      def ==(other)
+        return false unless other.is_a? self.class
+
+        instance_variables.all? { |v| instance_variable_get(v) == other.instance_variable_get(v) }
+      end
+
+      # Content type of the message body
+      # @return [String, nil]
+      attr_accessor :content_type
+      # Content encoding of the body
+      # @return [String, nil]
+      attr_accessor :content_encoding
+      # Headers, for applications and header exchange routing
+      # @return [Hash<String, Object>, nil]
+      attr_accessor :headers
+      # Message persistent level
+      # @note The exchange and queue have to durable as well for the message to be persistent
+      # @return [1] Transient message
+      # @return [2] Persistent message
+      # @return [nil] Not specified (implicitly transient)
+      attr_accessor :delivery_mode
+      # A priority of the message (between 0 and 255)
+      # @return [Integer, nil]
+      attr_accessor :priority
+      # Message correlation id, commonly used to correlate RPC requests and responses
+      # @return [String, nil]
+      attr_accessor :correlation_id
+      # Queue to reply RPC responses to
+      # @return [String, nil]
+      attr_accessor :reply_to
+      # Number of seconds the message will stay in the queue
+      # @return [String, nil]
+      attr_accessor :expiration
+      # Application message identifier
+      # @return [String, nil]
+      attr_accessor :message_id
+      # Message timestamp, often indicates when the message was originally generated
+      # @return [Date, nil]
+      attr_accessor :timestamp
+      # Message type name
+      # @return [String, nil]
+      attr_accessor :type
+      # The user that published the message
+      # @return [String, nil]
+      attr_accessor :user_id
+      # Name of application that generated the message
+      # @return [String, nil]
+      attr_accessor :app_id
+
       # Encode properties into a byte array
+      # @param properties [Hash]
       # @return [String] byte array
-      def encode
+      def self.encode(properties)
+        return "\x00\x00" if properties.empty?
+
         flags = 0
         arr = [flags]
-        fmt = StringIO.new(String.new("S>", capacity: 35))
-        fmt.pos = 2
+        fmt = String.new("S>", capacity: 37)
 
-        if content_type
+        if (content_type = properties[:content_type])
           content_type.is_a?(String) || raise(ArgumentError, "content_type must be a string")
 
           flags |= (1 << 15)
@@ -50,7 +117,7 @@ module AMQP
           fmt << "Ca*"
         end
 
-        if content_encoding
+        if (content_encoding = properties[:content_encoding])
           content_encoding.is_a?(String) || raise(ArgumentError, "content_encoding must be a string")
 
           flags |= (1 << 14)
@@ -58,7 +125,7 @@ module AMQP
           fmt << "Ca*"
         end
 
-        if headers
+        if (headers = properties[:headers])
           headers.is_a?(Hash) || raise(ArgumentError, "headers must be a hash")
 
           flags |= (1 << 13)
@@ -67,31 +134,31 @@ module AMQP
           fmt << "L>a*"
         end
 
-        if delivery_mode
+        if (delivery_mode = properties[:delivery_mode])
           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
           fmt << "C"
         end
 
-        if priority
+        if (priority = properties[:priority])
           priority.is_a?(Integer) || raise(ArgumentError, "priority must be an int")
+
           flags |= (1 << 11)
           arr << priority
           fmt << "C"
         end
 
-        if correlation_id
-          priority.is_a?(String) || raise(ArgumentError, "correlation_id must be a string")
+        if (correlation_id = properties[:correlation_id])
+          correlation_id.is_a?(String) || raise(ArgumentError, "correlation_id must be a string")
 
           flags |= (1 << 10)
           arr << correlation_id.bytesize << correlation_id
           fmt << "Ca*"
         end
 
-        if reply_to
+        if (reply_to = properties[:reply_to])
           reply_to.is_a?(String) || raise(ArgumentError, "reply_to must be a string")
 
           flags |= (1 << 9)
@@ -99,8 +166,8 @@ module AMQP
           fmt << "Ca*"
         end
 
-        if expiration
-          self.expiration = expiration.to_s if expiration.is_a?(Integer)
+        if (expiration = properties[:expiration])
+          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)
@@ -108,7 +175,7 @@ module AMQP
           fmt << "Ca*"
         end
 
-        if message_id
+        if (message_id = properties[:message_id])
           message_id.is_a?(String) || raise(ArgumentError, "message_id must be a string")
 
           flags |= (1 << 7)
@@ -116,7 +183,7 @@ module AMQP
           fmt << "Ca*"
         end
 
-        if timestamp
+        if (timestamp = properties[:timestamp])
           timestamp.is_a?(Integer) || timestamp.is_a?(Time) || raise(ArgumentError, "timestamp must be an Integer or a Time")
 
           flags |= (1 << 6)
@@ -124,7 +191,7 @@ module AMQP
           fmt << "Q>"
         end
 
-        if type
+        if (type = properties[:type])
           type.is_a?(String) || raise(ArgumentError, "type must be a string")
 
           flags |= (1 << 5)
@@ -132,7 +199,7 @@ module AMQP
           fmt << "Ca*"
         end
 
-        if user_id
+        if (user_id = properties[:user_id])
           user_id.is_a?(String) || raise(ArgumentError, "user_id must be a string")
 
           flags |= (1 << 4)
@@ -140,7 +207,7 @@ module AMQP
           fmt << "Ca*"
         end
 
-        if app_id
+        if (app_id = properties[:app_id])
           app_id.is_a?(String) || raise(ArgumentError, "app_id must be a string")
 
           flags |= (1 << 3)
@@ -149,87 +216,87 @@ module AMQP
         end
 
         arr[0] = flags
-        arr.pack(fmt.string)
+        arr.pack(fmt)
       end
 
       # Decode a byte array
       # @return [Properties]
-      def self.decode(bytes)
-        h = new
-        flags = bytes.unpack1("S>")
-        pos = 2
+      def self.decode(bytes, pos = 0)
+        p = new
+        flags = bytes.byteslice(pos, 2).unpack1("S>")
+        pos += 2
         if (flags & 0x8000).positive?
-          len = bytes[pos].ord
+          len = bytes.getbyte(pos)
           pos += 1
-          h[:content_type] = bytes.byteslice(pos, len).force_encoding("utf-8")
+          p.content_type = bytes.byteslice(pos, len).force_encoding("utf-8")
           pos += len
         end
         if (flags & 0x4000).positive?
-          len = bytes[pos].ord
+          len = bytes.getbyte(pos)
           pos += 1
-          h[:content_encoding] = bytes.byteslice(pos, len).force_encoding("utf-8")
+          p.content_encoding = bytes.byteslice(pos, len).force_encoding("utf-8")
           pos += len
         end
         if (flags & 0x2000).positive?
           len = bytes.byteslice(pos, 4).unpack1("L>")
           pos += 4
-          h[:headers] = Table.decode(bytes.byteslice(pos, len))
+          p.headers = Table.decode(bytes.byteslice(pos, len))
           pos += len
         end
         if (flags & 0x1000).positive?
-          h[:delivery_mode] = bytes[pos].ord
+          p.delivery_mode = bytes.getbyte(pos)
           pos += 1
         end
         if (flags & 0x0800).positive?
-          h[:priority] = bytes[pos].ord
+          p.priority = bytes.getbyte(pos)
           pos += 1
         end
         if (flags & 0x0400).positive?
-          len = bytes[pos].ord
+          len = bytes.getbyte(pos)
           pos += 1
-          h[:correlation_id] = bytes.byteslice(pos, len).force_encoding("utf-8")
+          p.correlation_id = bytes.byteslice(pos, len).force_encoding("utf-8")
           pos += len
         end
         if (flags & 0x0200).positive?
-          len = bytes[pos].ord
+          len = bytes.getbyte(pos)
           pos += 1
-          h[:reply_to] = bytes.byteslice(pos, len).force_encoding("utf-8")
+          p.reply_to = bytes.byteslice(pos, len).force_encoding("utf-8")
           pos += len
         end
         if (flags & 0x0100).positive?
-          len = bytes[pos].ord
+          len = bytes.getbyte(pos)
           pos += 1
-          h[:expiration] = bytes.byteslice(pos, len).force_encoding("utf-8")
+          p.expiration = bytes.byteslice(pos, len).force_encoding("utf-8")
           pos += len
         end
         if (flags & 0x0080).positive?
-          len = bytes[pos].ord
+          len = bytes.getbyte(pos)
           pos += 1
-          h[:message_id] = bytes.byteslice(pos, len).force_encoding("utf-8")
+          p.message_id = bytes.byteslice(pos, len).force_encoding("utf-8")
           pos += len
         end
         if (flags & 0x0040).positive?
-          h[:timestamp] = Time.at(bytes.byteslice(pos, 8).unpack1("Q>"))
+          p.timestamp = Time.at(bytes.byteslice(pos, 8).unpack1("Q>"))
           pos += 8
         end
         if (flags & 0x0020).positive?
-          len = bytes[pos].ord
+          len = bytes.getbyte(pos)
           pos += 1
-          h[:type] = bytes.byteslice(pos, len).force_encoding("utf-8")
+          p.type = bytes.byteslice(pos, len).force_encoding("utf-8")
           pos += len
         end
         if (flags & 0x0010).positive?
-          len = bytes[pos].ord
+          len = bytes.getbyte(pos)
           pos += 1
-          h[:user_id] = bytes.byteslice(pos, len).force_encoding("utf-8")
+          p.user_id = bytes.byteslice(pos, len).force_encoding("utf-8")
           pos += len
         end
         if (flags & 0x0008).positive?
-          len = bytes[pos].ord
+          len = bytes.getbyte(pos)
           pos += 1
-          h[:app_id] = bytes.byteslice(pos, len).force_encoding("utf-8")
+          p.app_id = bytes.byteslice(pos, len).force_encoding("utf-8")
         end
-        h
+        p
       end
     end
   end

data/lib/amqp/client/queue.rb

@@ -11,30 +11,24 @@ module AMQP
         @name = name
       end
 
-      # Publish to the queue
-      # @param body [String] The message body
-      # @param properties [Properties]
-      # @option properties [String] content_type Content type of the message body
-      # @option properties [String] content_encoding Content encoding of the body
-      # @option properties [Hash<String, Object>] headers Custom headers
-      # @option properties [Integer] delivery_mode 2 for persisted message, transient messages for all other values
-      # @option properties [Integer] priority A priority of the message (between 0 and 255)
-      # @option properties [Integer] correlation_id A correlation id, most often used used for RPC communication
-      # @option properties [String] reply_to Queue to reply RPC responses to
-      # @option properties [Integer, String] expiration Number of seconds the message will stay in the queue
-      # @option properties [String] message_id Can be used to uniquely identify the message, e.g. for deduplication
-      # @option properties [Date] timestamp Often used for the time the message was originally generated
-      # @option properties [String] type Can indicate what kind of message this is
-      # @option properties [String] user_id Can be used to verify that this is the user that published the message
-      # @option properties [String] app_id Can be used to indicates which app that generated the message
-      # @return [Queue] self
+      # Publish to the queue, wait for confirm
+      # @param (see Client#publish)
+      # @option (see Client#publish)
+      # @raise (see Client#publish)
+      # @return [self]
       def publish(body, **properties)
         @client.publish(body, "", @name, **properties)
         self
       end
 
       # Subscribe/consume from the queue
-      # @return [Queue] self
+      # @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 arguments [Hash] Custom arguments to the consumer
+      # @yield [Message] Delivered message from the queue
+      # @return [self]
       def subscribe(no_ack: false, prefetch: 1, worker_threads: 1, arguments: {}, &blk)
         @client.subscribe(@name, no_ack: no_ack, prefetch: prefetch, worker_threads: worker_threads, arguments: arguments, &blk)
         self
@@ -44,7 +38,7 @@ module AMQP
       # @param exchange [String] Name of the exchange to bind to
       # @param binding_key [String] Binding key on which messages that match might be routed (depending on exchange type)
       # @param arguments [Hash] Message headers to match on (only relevant for header exchanges)
-      # @return [Queue] self
+      # @return [self]
       def bind(exchange, binding_key, arguments: {})
         @client.bind(@name, exchange, binding_key, arguments: arguments)
         self
@@ -54,14 +48,14 @@ module AMQP
       # @param exchange [String] Name of the exchange to unbind from
       # @param binding_key [String] Binding key which the queue is bound to the exchange with
       # @param arguments [Hash] Arguments matching the binding that's being removed
-      # @return [Queue] self
+      # @return [self]
       def unbind(exchange, binding_key, arguments: {})
         @client.unbind(@name, exchange, binding_key, arguments: arguments)
         self
       end
 
       # Purge/empty the queue
-      # @return [Queue] self
+      # @return [self]
       def purge
         @client.purge(@name)
         self

data/lib/amqp/client/table.rb

@@ -5,32 +5,34 @@ module AMQP
     # Encode and decode an AMQP table to/from hash, only used internally
     # @api private
     module Table
-      module_function
-
       # Encodes a hash into a byte array
+      # @param hash [Hash]
       # @return [String] Byte array
-      def encode(hash)
-        tbl = StringIO.new
-        hash.each do |k, v|
+      def self.encode(hash)
+        return "" if hash.empty?
+
+        arr = []
+        fmt = String.new
+        hash.each do |k, value|
           key = k.to_s
-          tbl.write [key.bytesize, key].pack("Ca*")
-          tbl.write encode_field(v)
+          arr.push(key.bytesize, key)
+          fmt << "Ca*"
+          encode_field(value, arr, fmt)
         end
-        tbl.string
+        arr.pack(fmt)
       end
 
       # Decodes an AMQP table into a hash
       # @return [Hash<String, Object>]
-      def decode(bytes)
+      def self.decode(bytes)
         hash = {}
         pos = 0
         while pos < bytes.bytesize
-          key_len = bytes[pos].ord
+          key_len = bytes.getbyte(pos)
           pos += 1
           key = bytes.byteslice(pos, key_len).force_encoding("utf-8")
           pos += key_len
-          rest = bytes.byteslice(pos, bytes.bytesize - pos)
-          len, value = decode_field(rest)
+          len, value = decode_field(bytes, pos)
           pos += len + 1
           hash[key] = value
         end
@@ -38,43 +40,58 @@ module AMQP
       end
 
       # Encoding a single value in a table
+      # @return [nil]
       # @api private
-      def encode_field(value)
+      def self.encode_field(value, arr, fmt)
         case value
         when Integer
           if value > 2**31
-            ["l", value].pack("a q>")
+            arr.push("l", value)
+            fmt << "aq>"
           else
-            ["I", value].pack("a l>")
+            arr.push("I", value)
+            fmt << "al>"
           end
         when Float
-          ["d", value].pack("a G")
+          arr.push("d", value)
+          fmt << "aG"
         when String
-          ["S", value.bytesize, value].pack("a L> a*")
+          arr.push("S", value.bytesize, value)
+          fmt << "aL>a*"
         when Time
-          ["T", value.to_i].pack("a Q>")
+          arr.push("T", value.to_i)
+          fmt << "aQ>"
         when Array
-          bytes = value.map { |e| encode_field(e) }.join
-          ["A", bytes.bytesize, bytes].pack("a L> a*")
+          value_arr = []
+          value_fmt = String.new
+          value.each { |e| encode_field(e, value_arr, value_fmt) }
+          bytes = value_arr.pack(value_fmt)
+          arr.push("A", bytes.bytesize, bytes)
+          fmt << "aL>a*"
         when Hash
           bytes = Table.encode(value)
-          ["F", bytes.bytesize, bytes].pack("a L> a*")
+          arr.push("F", bytes.bytesize, bytes)
+          fmt << "aL>a*"
         when true
-          ["t", 1].pack("a C")
+          arr.push("t", 1)
+          fmt << "aC"
         when false
-          ["t", 0].pack("a C")
+          arr.push("t", 0)
+          fmt << "aC"
         when nil
-          ["V"].pack("a")
+          arr << "V"
+          fmt << "a"
         else raise ArgumentError, "unsupported table field type: #{value.class}"
         end
+        nil
       end
 
       # Decodes a single value
-      # @return [Array<Integer, Object>] Bytes read and the parsed object
+      # @return [Array<Integer, Object>] Bytes read and the parsed value
       # @api private
-      def decode_field(bytes)
-        type = bytes[0]
-        pos = 1
+      def self.decode_field(bytes, pos)
+        type = bytes[pos]
+        pos += 1
         case type
         when "S"
           len = bytes.byteslice(pos, 4).unpack1("L>")
@@ -86,15 +103,17 @@ module AMQP
           [4 + len, decode(bytes.byteslice(pos, len))]
         when "A"
           len = bytes.byteslice(pos, 4).unpack1("L>")
+          pos += 4
+          array_end = pos + len
           a = []
-          while pos < len
-            length, value = decode_field(bytes.byteslice(pos, -1))
+          while pos < array_end
+            length, value = decode_field(bytes, pos)
             pos += length + 1
             a << value
           end
           [4 + len, a]
         when "t"
-          [1, bytes[pos].ord == 1]
+          [1, bytes.getbyte(pos) == 1]
         when "b"
           [1, bytes.byteslice(pos, 1).unpack1("c")]
         when "B"
@@ -114,7 +133,7 @@ module AMQP
         when "d"
           [8, bytes.byteslice(pos, 8).unpack1("G")]
         when "D"
-          scale = bytes[pos].ord
+          scale = bytes.getbyte(pos)
           pos += 1
           value = bytes.byteslice(pos, 4).unpack1("L>")
           d = value / 10**scale

data/lib/amqp/client/version.rb

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