amqp-client 1.0.0 → 1.1.1

data/lib/amqp/client/message.rb

@@ -1,15 +1,111 @@
 # frozen_string_literal: true
 
 module AMQP
-  Message = Struct.new(:channel, :delivery_tag, :exchange_name, :routing_key, :properties, :body, :redelivered, :consumer_tag) do
-    def ack
-      channel.basic_ack(delivery_tag)
+  class Client
+    # A message delivered from the broker
+    class Message
+      # @api private
+      def initialize(channel, consumer_tag, delivery_tag, exchange, routing_key, redelivered)
+        @channel = channel
+        @consumer_tag = consumer_tag
+        @delivery_tag = delivery_tag
+        @exchange = exchange
+        @routing_key = routing_key
+        @redelivered = redelivered
+        @properties = nil
+        @body = ""
+      end
+
+      # The channel the message was deliviered to
+      # @return [Connection::Channel]
+      attr_reader :channel
+
+      # The tag of the consumer the message was deliviered to
+      # @return [String]
+      # @return [nil] If the message was polled and not deliviered to a consumer
+      attr_reader :consumer_tag
+
+      # The delivery tag of the message, used for acknowledge or reject the message
+      # @return [Integer]
+      attr_reader :delivery_tag
+
+      # Name of the exchange the message was published to
+      # @return [String]
+      attr_reader :exchange
+
+      # The routing key the message was published with
+      # @return [String]
+      attr_reader :routing_key
+
+      # True if the message have been delivered before
+      # @return [Boolean]
+      attr_reader :redelivered
+
+      # Message properties
+      # @return [Properties]
+      attr_accessor :properties
+
+      # The message body
+      # @return [String]
+      attr_accessor :body
+
+      # Acknowledge the message
+      # @return [nil]
+      def ack
+        @channel.basic_ack(@delivery_tag)
+      end
+
+      # Reject the message
+      # @param requeue [Boolean] If true the message will be put back into the queue again, ready to be redelivered
+      # @return [nil]
+      def reject(requeue: false)
+        @channel.basic_reject(@delivery_tag, requeue: requeue)
+      end
+
+      # @see #exchange
+      # @deprecated
+      # @!attribute [r] exchange_name
+      # @return [String]
+      def exchange_name
+        @exchange
+      end
     end
 
-    def reject(requeue: false)
-      channel.basic_reject(delivery_tag, requeue: requeue)
+    # A published message returned by the broker due to some error
+    class ReturnMessage
+      # @api private
+      def initialize(reply_code, reply_text, exchange, routing_key)
+        @reply_code = reply_code
+        @reply_text = reply_text
+        @exchange = exchange
+        @routing_key = routing_key
+        @properties = nil
+        @body = ""
+      end
+
+      # Error code
+      # @return [Integer]
+      attr_reader :reply_code
+
+      # Description on why the message was returned
+      # @return [String]
+      attr_reader :reply_text
+
+      # Name of the exchange the message was published to
+      # @return [String]
+      attr_reader :exchange
+
+      # The routing key the message was published with
+      # @return [String]
+      attr_reader :routing_key
+
+      # Message properties
+      # @return [Properties]
+      attr_accessor :properties
+
+      # The message body
+      # @return [String]
+      attr_accessor :body
     end
   end
-
-  ReturnMessage = Struct.new(:reply_code, :reply_text, :exchange, :routing_key, :properties, :body)
 end

data/lib/amqp/client/properties.rb

@@ -3,201 +3,298 @@
 require_relative "./table"
 
 module AMQP
-  # Encode/decode AMQP Properties
-  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
-    def encode
-      flags = 0
-      arr = [flags]
-      fmt = String.new("S>")
-
-      if content_type
-        content_type.is_a?(String) || raise(ArgumentError, "content_type must be a string")
-
-        flags |= (1 << 15)
-        arr << content_type.bytesize << content_type
-        fmt << "Ca*"
+  class Client
+    # Encode/decode AMQP Properties
+    class Properties
+      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
 
-      if content_encoding
-        content_encoding.is_a?(String) || raise(ArgumentError, "content_encoding must be a string")
-
-        flags |= (1 << 14)
-        arr << content_encoding.bytesize << content_encoding
-        fmt << "Ca*"
+      # 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
 
-      if headers
-        headers.is_a?(Hash) || raise(ArgumentError, "headers must be a hash")
+      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
 
-        flags |= (1 << 13)
-        tbl = Table.encode(headers)
-        arr << tbl.bytesize << tbl
-        fmt << "L>a*"
+        instance_variables.all? { |v| instance_variable_get(v) == other.instance_variable_get(v) }
       end
 
-      if 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")
+      # 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
 
-        flags |= (1 << 12)
-        arr << delivery_mode
-        fmt << "C"
-      end
+      # Encode properties into a byte array
+      # @param properties [Hash]
+      # @return [String] byte array
+      def self.encode(properties)
+        return "\x00\x00" if properties.empty?
 
-      if priority
-        priority.is_a?(Integer) || raise(ArgumentError, "priority must be an int")
-        flags |= (1 << 11)
-        arr << priority
-        fmt << "C"
-      end
+        flags = 0
+        arr = [flags]
+        fmt = String.new("S>", capacity: 37)
 
-      if correlation_id
-        priority.is_a?(String) || raise(ArgumentError, "correlation_id must be a string")
+        if (content_type = properties[:content_type])
+          content_type.is_a?(String) || raise(ArgumentError, "content_type must be a string")
 
-        flags |= (1 << 10)
-        arr << correlation_id.bytesize << correlation_id
-        fmt << "Ca*"
-      end
+          flags |= (1 << 15)
+          arr << content_type.bytesize << content_type
+          fmt << "Ca*"
+        end
 
-      if reply_to
-        reply_to.is_a?(String) || raise(ArgumentError, "reply_to must be a string")
+        if (content_encoding = properties[:content_encoding])
+          content_encoding.is_a?(String) || raise(ArgumentError, "content_encoding must be a string")
 
-        flags |= (1 << 9)
-        arr << reply_to.bytesize << reply_to
-        fmt << "Ca*"
-      end
+          flags |= (1 << 14)
+          arr << content_encoding.bytesize << content_encoding
+          fmt << "Ca*"
+        end
 
-      if expiration
-        self.expiration = expiration.to_s if expiration.is_a?(Integer)
-        expiration.is_a?(String) || raise(ArgumentError, "expiration must be a string or integer")
+        if (headers = properties[:headers])
+          headers.is_a?(Hash) || raise(ArgumentError, "headers must be a hash")
 
-        flags |= (1 << 8)
-        arr << expiration.bytesize << expiration
-        fmt << "Ca*"
-      end
+          flags |= (1 << 13)
+          tbl = Table.encode(headers)
+          arr << tbl.bytesize << tbl
+          fmt << "L>a*"
+        end
 
-      if message_id
-        message_id.is_a?(String) || raise(ArgumentError, "message_id must be a string")
+        if (delivery_mode = properties[:delivery_mode])
+          delivery_mode.is_a?(Integer) || raise(ArgumentError, "delivery_mode must be an int")
 
-        flags |= (1 << 7)
-        arr << message_id.bytesize << message_id
-        fmt << "Ca*"
-      end
+          flags |= (1 << 12)
+          arr << delivery_mode
+          fmt << "C"
+        end
 
-      if timestamp
-        timestamp.is_a?(Integer) || timestamp.is_a?(Time) || raise(ArgumentError, "timestamp must be an Integer or a Time")
+        if (priority = properties[:priority])
+          priority.is_a?(Integer) || raise(ArgumentError, "priority must be an int")
 
-        flags |= (1 << 6)
-        arr << timestamp.to_i
-        fmt << "Q>"
-      end
+          flags |= (1 << 11)
+          arr << priority
+          fmt << "C"
+        end
 
-      if type
-        type.is_a?(String) || raise(ArgumentError, "type 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 << 5)
-        arr << type.bytesize << type
-        fmt << "Ca*"
-      end
+          flags |= (1 << 10)
+          arr << correlation_id.bytesize << correlation_id
+          fmt << "Ca*"
+        end
 
-      if user_id
-        user_id.is_a?(String) || raise(ArgumentError, "user_id must be a string")
+        if (reply_to = properties[:reply_to])
+          reply_to.is_a?(String) || raise(ArgumentError, "reply_to must be a string")
 
-        flags |= (1 << 4)
-        arr << user_id.bytesize << user_id
-        fmt << "Ca*"
-      end
+          flags |= (1 << 9)
+          arr << reply_to.bytesize << reply_to
+          fmt << "Ca*"
+        end
 
-      if app_id
-        app_id.is_a?(String) || raise(ArgumentError, "app_id must be a string")
+        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 << 3)
-        arr << app_id.bytesize << app_id
-        fmt << "Ca*"
-      end
+          flags |= (1 << 8)
+          arr << expiration.bytesize << expiration
+          fmt << "Ca*"
+        end
 
-      arr[0] = flags
-      arr.pack(fmt)
-    end
+        if (message_id = properties[:message_id])
+          message_id.is_a?(String) || raise(ArgumentError, "message_id must be a string")
 
-    def self.decode(bytes)
-      h = new
-      flags = bytes.unpack1("S>")
-      pos = 2
-      if (flags & 0x8000).positive?
-        len = bytes[pos].ord
-        pos += 1
-        h[:content_type] = bytes.byteslice(pos, len).force_encoding("utf-8")
-        pos += len
-      end
-      if (flags & 0x4000).positive?
-        len = bytes[pos].ord
-        pos += 1
-        h[: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))
-        pos += len
-      end
-      if (flags & 0x1000).positive?
-        h[:delivery_mode] = bytes[pos].ord
-        pos += 1
-      end
-      if (flags & 0x0800).positive?
-        h[:priority] = bytes[pos].ord
-        pos += 1
-      end
-      if (flags & 0x0400).positive?
-        len = bytes[pos].ord
-        pos += 1
-        h[:correlation_id] = bytes.byteslice(pos, len).force_encoding("utf-8")
-        pos += len
-      end
-      if (flags & 0x0200).positive?
-        len = bytes[pos].ord
-        pos += 1
-        h[:reply_to] = bytes.byteslice(pos, len).force_encoding("utf-8")
-        pos += len
-      end
-      if (flags & 0x0100).positive?
-        len = bytes[pos].ord
-        pos += 1
-        h[:expiration] = bytes.byteslice(pos, len).force_encoding("utf-8")
-        pos += len
-      end
-      if (flags & 0x0080).positive?
-        len = bytes[pos].ord
-        pos += 1
-        h[: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>"))
-        pos += 8
-      end
-      if (flags & 0x0020).positive?
-        len = bytes[pos].ord
-        pos += 1
-        h[:type] = bytes.byteslice(pos, len).force_encoding("utf-8")
-        pos += len
-      end
-      if (flags & 0x0010).positive?
-        len = bytes[pos].ord
-        pos += 1
-        h[:user_id] = bytes.byteslice(pos, len).force_encoding("utf-8")
-        pos += len
+          flags |= (1 << 7)
+          arr << message_id.bytesize << message_id
+          fmt << "Ca*"
+        end
+
+        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)
+          arr << timestamp.to_i
+          fmt << "Q>"
+        end
+
+        if (type = properties[:type])
+          type.is_a?(String) || raise(ArgumentError, "type must be a string")
+
+          flags |= (1 << 5)
+          arr << type.bytesize << type
+          fmt << "Ca*"
+        end
+
+        if (user_id = properties[:user_id])
+          user_id.is_a?(String) || raise(ArgumentError, "user_id must be a string")
+
+          flags |= (1 << 4)
+          arr << user_id.bytesize << user_id
+          fmt << "Ca*"
+        end
+
+        if (app_id = properties[:app_id])
+          app_id.is_a?(String) || raise(ArgumentError, "app_id must be a string")
+
+          flags |= (1 << 3)
+          arr << app_id.bytesize << app_id
+          fmt << "Ca*"
+        end
+
+        arr[0] = flags
+        arr.pack(fmt)
       end
-      if (flags & 0x0008).positive?
-        len = bytes[pos].ord
-        pos += 1
-        h[:app_id] = bytes.byteslice(pos, len).force_encoding("utf-8")
+
+      # Decode a byte array
+      # @return [Properties]
+      def self.decode(bytes, pos = 0)
+        p = new
+        flags = bytes.byteslice(pos, 2).unpack1("S>")
+        pos += 2
+        if (flags & 0x8000).positive?
+          len = bytes.getbyte(pos)
+          pos += 1
+          p.content_type = bytes.byteslice(pos, len).force_encoding("utf-8")
+          pos += len
+        end
+        if (flags & 0x4000).positive?
+          len = bytes.getbyte(pos)
+          pos += 1
+          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
+          p.headers = Table.decode(bytes.byteslice(pos, len))
+          pos += len
+        end
+        if (flags & 0x1000).positive?
+          p.delivery_mode = bytes.getbyte(pos)
+          pos += 1
+        end
+        if (flags & 0x0800).positive?
+          p.priority = bytes.getbyte(pos)
+          pos += 1
+        end
+        if (flags & 0x0400).positive?
+          len = bytes.getbyte(pos)
+          pos += 1
+          p.correlation_id = bytes.byteslice(pos, len).force_encoding("utf-8")
+          pos += len
+        end
+        if (flags & 0x0200).positive?
+          len = bytes.getbyte(pos)
+          pos += 1
+          p.reply_to = bytes.byteslice(pos, len).force_encoding("utf-8")
+          pos += len
+        end
+        if (flags & 0x0100).positive?
+          len = bytes.getbyte(pos)
+          pos += 1
+          p.expiration = bytes.byteslice(pos, len).force_encoding("utf-8")
+          pos += len
+        end
+        if (flags & 0x0080).positive?
+          len = bytes.getbyte(pos)
+          pos += 1
+          p.message_id = bytes.byteslice(pos, len).force_encoding("utf-8")
+          pos += len
+        end
+        if (flags & 0x0040).positive?
+          p.timestamp = Time.at(bytes.byteslice(pos, 8).unpack1("Q>"))
+          pos += 8
+        end
+        if (flags & 0x0020).positive?
+          len = bytes.getbyte(pos)
+          pos += 1
+          p.type = bytes.byteslice(pos, len).force_encoding("utf-8")
+          pos += len
+        end
+        if (flags & 0x0010).positive?
+          len = bytes.getbyte(pos)
+          pos += 1
+          p.user_id = bytes.byteslice(pos, len).force_encoding("utf-8")
+          pos += len
+        end
+        if (flags & 0x0008).positive?
+          len = bytes.getbyte(pos)
+          pos += 1
+          p.app_id = bytes.byteslice(pos, len).force_encoding("utf-8")
+        end
+        p
       end
-      h
     end
   end
 end