amqp-client 0.3.0 → 1.1.0

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)
+    # 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,200 +3,264 @@
 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")
+      # 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
+      # Custom headers
+      # @return [Hash<String, Object>, nil]
+      attr_accessor :headers
+      # 2 for persisted message, transient messages for all other values
+      # @return [Integer, nil]
+      attr_accessor :delivery_mode
+      # A priority of the message (between 0 and 255)
+      # @return [Integer, nil]
+      attr_accessor :priority
+      # A correlation id, most often used used for RPC communication
+      # @return [Integer, 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 [Integer]
+      # @return [String]
+      # @return [nil]
+      attr_accessor :expiration
+      # @return [String, nil]
+      attr_accessor :message_id
+      # User-definable, but often used for the time the message was originally generated
+      # @return [Date, nil]
+      attr_accessor :timestamp
+      # User-definable, but can can indicate what kind of message this is
+      # @return [String, nil]
+      attr_accessor :type
+      # User-definable, but can be used to verify that this is the user that published the message
+      # @return [String, nil]
+      attr_accessor :user_id
+      # User-definable, but often indicates which app that generated the message
+      # @return [String, nil]
+      attr_accessor :app_id
 
-        flags |= (1 << 14)
-        arr << content_encoding.bytesize << content_encoding
-        fmt << "Ca*"
-      end
+      # Encode properties into a byte array
+      # @return [String] byte array
+      def encode
+        flags = 0
+        arr = [flags]
+        fmt = StringIO.new(String.new("S>", capacity: 35))
+        fmt.pos = 2
 
-      if headers
-        headers.is_a?(Hash) || raise(ArgumentError, "headers must be a hash")
+        if content_type
+          content_type.is_a?(String) || raise(ArgumentError, "content_type must be a string")
 
-        flags |= (1 << 13)
-        tbl = Table.encode(headers)
-        arr << tbl.bytesize << tbl
-        fmt << "L>a*"
-      end
+          flags |= (1 << 15)
+          arr << content_type.bytesize << content_type
+          fmt << "Ca*"
+        end
 
-      if delivery_mode
-        headers.is_a?(Integer) || raise(ArgumentError, "delivery_mode must be an int")
+        if content_encoding
+          content_encoding.is_a?(String) || raise(ArgumentError, "content_encoding must be a string")
 
-        flags |= (1 << 12)
-        arr << delivery_mode
-        fmt << "C"
-      end
+          flags |= (1 << 14)
+          arr << content_encoding.bytesize << content_encoding
+          fmt << "Ca*"
+        end
 
-      if priority
-        priority.is_a?(Integer) || raise(ArgumentError, "priority must be an int")
-        flags |= (1 << 11)
-        arr << priority
-        fmt << "C"
-      end
+        if headers
+          headers.is_a?(Hash) || raise(ArgumentError, "headers must be a hash")
 
-      if correlation_id
-        priority.is_a?(String) || raise(ArgumentError, "correlation_id must be a string")
+          flags |= (1 << 13)
+          tbl = Table.encode(headers)
+          arr << tbl.bytesize << tbl
+          fmt << "L>a*"
+        end
 
-        flags |= (1 << 10)
-        arr << correlation_id.bytesize << correlation_id
-        fmt << "Ca*"
-      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")
 
-      if reply_to
-        reply_to.is_a?(String) || raise(ArgumentError, "reply_to must be a string")
+          flags |= (1 << 12)
+          arr << delivery_mode
+          fmt << "C"
+        end
 
-        flags |= (1 << 9)
-        arr << reply_to.bytesize << reply_to
-        fmt << "Ca*"
-      end
+        if priority
+          priority.is_a?(Integer) || raise(ArgumentError, "priority must be an int")
+          flags |= (1 << 11)
+          arr << priority
+          fmt << "C"
+        end
 
-      if expiration
-        expiration = expiration.to_s if expiration.is_a?(Integer)
-        expiration.is_a?(String) || raise(ArgumentError, "expiration must be a string or integer")
+        if correlation_id
+          priority.is_a?(String) || raise(ArgumentError, "correlation_id must be a string")
 
-        flags |= (1 << 8)
-        arr << expiration.bytesize << expiration
-        fmt << "Ca*"
-      end
+          flags |= (1 << 10)
+          arr << correlation_id.bytesize << correlation_id
+          fmt << "Ca*"
+        end
 
-      if message_id
-        message_id.is_a?(String) || raise(ArgumentError, "message_id must be a string")
+        if reply_to
+          reply_to.is_a?(String) || raise(ArgumentError, "reply_to must be a string")
 
-        flags |= (1 << 7)
-        arr << message_id.bytesize << message_id
-        fmt << "Ca*"
-      end
+          flags |= (1 << 9)
+          arr << reply_to.bytesize << reply_to
+          fmt << "Ca*"
+        end
 
-      if timestamp
-        timestamp.is_a?(Time) || raise(ArgumentError, "timestamp must be a time")
+        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")
 
-        flags |= (1 << 6)
-        arr << timestamp.to_i
-        fmt << "Q>"
-      end
+          flags |= (1 << 8)
+          arr << expiration.bytesize << expiration
+          fmt << "Ca*"
+        end
 
-      if type
-        type.is_a?(String) || raise(ArgumentError, "type must be a string")
+        if message_id
+          message_id.is_a?(String) || raise(ArgumentError, "message_id must be a string")
 
-        flags |= (1 << 5)
-        arr << type.bytesize << type
-        fmt << "Ca*"
-      end
+          flags |= (1 << 7)
+          arr << message_id.bytesize << message_id
+          fmt << "Ca*"
+        end
 
-      if user_id
-        user_id.is_a?(String) || raise(ArgumentError, "user_id must be a string")
+        if timestamp
+          timestamp.is_a?(Integer) || timestamp.is_a?(Time) || raise(ArgumentError, "timestamp must be an Integer or a Time")
 
-        flags |= (1 << 4)
-        arr << user_id.bytesize << user_id
-        fmt << "Ca*"
-      end
+          flags |= (1 << 6)
+          arr << timestamp.to_i
+          fmt << "Q>"
+        end
 
-      if app_id
-        app_id.is_a?(String) || raise(ArgumentError, "app_id must be a string")
+        if type
+          type.is_a?(String) || raise(ArgumentError, "type must be a string")
 
-        flags |= (1 << 3)
-        arr << app_id.bytesize << app_id
-        fmt << "Ca*"
-      end
+          flags |= (1 << 5)
+          arr << type.bytesize << type
+          fmt << "Ca*"
+        end
 
-      arr[0] = flags
-      arr.pack(fmt)
-    end
+        if user_id
+          user_id.is_a?(String) || raise(ArgumentError, "user_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 << 4)
+          arr << user_id.bytesize << user_id
+          fmt << "Ca*"
+        end
+
+        if 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.string)
       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)
+        p = new
+        flags = bytes.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