class AWS::SQS::Queue

Represents an Amazon SQS Queue.

@example Sending a message

msg = queue.send_message("HELLO")
puts "Sent message: #{msg.id}"

@example Polling for messages indefinitely

queue.poll do |msg|
  puts "Got message: #{msg.body}"
end

Constants

DEFAULT_POLL_INTERVAL

The default number of seconds to wait between polling requests for new messages. @deprecated No longer used by {#poll}

DEFAULT_WAIT_TIME_SECONDS

The default number of seconds to pass in as the SQS long polling value (‘:wait_time_seconds`) in {#receive_message}.

@since 1.8.0

Attributes

url[R]

@return [String] The queue URL.

Public Class Methods

new(url, opts = {}) click to toggle source

@api private

Calls superclass method AWS::Core::Model::new
# File lib/aws/sqs/queue.rb, line 51
def initialize(url, opts = {})
  @url = url
  super
end

Public Instance Methods

==(other) click to toggle source

@return [Boolean] Returns true if the other queue has the same

url.
# File lib/aws/sqs/queue.rb, line 684
def ==(other)
  other.kind_of?(Queue) and other.url == url
end
Also aliased as: eql?
approximate_number_of_messages() click to toggle source

@return [Integer] The approximate number of visible messages

in a queue.  For more information, see
[Resources Required to Process Messages](http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/IntroductionArticle.html#ApproximateNumber)
in the Amazon SQS Developer Guide.
# File lib/aws/sqs/queue.rb, line 319
def approximate_number_of_messages
  get_attribute("ApproximateNumberOfMessages").to_i
end
Also aliased as: visible_messages
approximate_number_of_messages_delayed() click to toggle source

@return [Integer] Returns an approximate count of messages delayed.

# File lib/aws/sqs/queue.rb, line 428
def approximate_number_of_messages_delayed
  get_attribute("ApproximateNumberOfMessagesDelayed").to_i
end
approximate_number_of_messages_not_visible() click to toggle source

@return [Integer] The approximate number of messages that

are not timed-out and not deleted.  For more information,
see [Resources Required to Process Messages](http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/IntroductionArticle.html#ApproximateNumber)
in the Amazon SQS Developer Guide.
# File lib/aws/sqs/queue.rb, line 328
def approximate_number_of_messages_not_visible
  get_attribute("ApproximateNumberOfMessagesNotVisible").to_i
end
Also aliased as: invisible_messages
arn() click to toggle source

@return [String] The queue’s Amazon resource name (ARN).

# File lib/aws/sqs/queue.rb, line 433
def arn
  @arn ||= get_attribute("QueueArn")
end
batch_change_visibility(*args) click to toggle source

@overload batch_change_visibility(visibility_timeout, *messages)

Accepts a single `:visibility_timeout` value and a list of
messages ({ReceivedMessage} objects or receipt handle strings).
This form of the method is useful when you want to set the same
timeout value for each message.

    queue.batch_change_visibility(10, messages)

@param [Integer] visibility_timeout The new value for the message's
  visibility timeout (in seconds).

@param [ReceivedMessage,String] message A list of up to 10 messages
  to change the visibility timeout for.

@raise [BatchChangeVisibilityError] Raises this error when one
  or more of the messages failed the visibility update.

@return [nil]

@overload batch_change_visibility(*messages_with_timeouts)

Accepts a list of hashes.  Each hash should provide the visibility
timeout and message (a {ReceivedMessage} object or the recipt handle
string).

Use this form when each message needs a different visiblity timeout.

    messages = []
    messages << { :message => 'handle1', :visibility_timeout => 5 }
    messages << { :message => 'handle2', :visibility_timeout => 10 }

    queue.batch_change_visibility(*messages)

@param [Hash] message A list hashes, each with a `:visibility_timeout`
  and a `:message`.

@raise [BatchChangeVisibilityError] Raises this error when one
  or more of the messages failed the visibility update.

@return [nil]
# File lib/aws/sqs/queue.rb, line 649
def batch_change_visibility *args

  args = args.flatten

  if args.first.is_a?(Integer)
    timeout = args.shift
    messages = args.collect{|m| [m, timeout] }
  else
    messages = args.collect{|m| [m[:message], m[:visibility_timeout]] }
  end

  entries = []
  messages.each do |msg,timeout|
    handle = msg.is_a?(ReceivedMessage) ? msg.handle : msg
    entries << {
      :id => entries.size.to_s,
      :receipt_handle => handle,
      :visibility_timeout => timeout,
    }
  end

  response = client.change_message_visibility_batch(
    :queue_url => url, :entries => entries)

  failures = batch_failures(entries, response)

  raise Errors::BatchChangeVisibilityError.new(failures) unless
    failures.empty?

  nil

end
batch_delete(*messages) click to toggle source

@param [ReceivedMessage,String] messages A list of up to 10 messages

to delete.  Each message should be a {ReceivedMessage} object
or a received message handle (string).

@raise [Errors::BatchDeleteSend] Raised when one or more of the

messages failed to delete.  The raised error has a list
of the failures.

@return [nil]

# File lib/aws/sqs/queue.rb, line 588
def batch_delete *messages

  entries = []
  messages.flatten.each_with_index do |msg,n|
    handle = msg.is_a?(ReceivedMessage) ? msg.handle : msg
    entries << { :id => n.to_s, :receipt_handle => handle }
  end

  response = client.delete_message_batch(
    :queue_url => url, :entries => entries)

  failures = batch_failures(entries, response)

  raise Errors::BatchDeleteError.new(failures) unless failures.empty?

  nil

end
batch_send(*messages) click to toggle source

Sends a batch of up to 10 messages in a single request.

queue.send_messages('message-1', 'message-2')

You can also set an optional delay for all of the messages:

# delay all messages 15 minutes
queue.batch_send(msg1, msg2, :delay_seconds => 900)

If you need to set a custom delay for each message you can pass hashes:

messages = []
messages << { :message_body => 'msg1', :delay_seconds => 60 }
messages << { :message_body => 'msg2', :delay_seconds => 30 }

queue.batch_send(messages)

@param [String,Hash] messages A list of messages. Each message

should be a string, or a hash with a `:message_body`,
and optionally `:delay_seconds`.

@raise [Errors::BatchSendError] Raises this error when one or more

of the messages failed to send, but others did not.  On the raised
object you can access a list of the messages that failed, and
a list of messages that succeeded.

@return [Array<SentMessage>] Returns an array of sent message objects.

Each object responds to #message_id and #md5_of_message_body.
The message id is generated by Amazon SQS.
# File lib/aws/sqs/queue.rb, line 533
def batch_send *messages

  entries = messages.flatten

  unless entries.first.is_a?(Hash)
    options = entries.last.is_a?(Hash) ? entries.pop : {}
    entries = entries.collect{|msg| { :message_body => msg } }
    if delay = options[:delay_seconds]
      entries.each {|entry| entry[:delay_seconds] = delay }
    end
  end

  entries.each_with_index {|entry,n| entry[:id] = n.to_s }

  client_opts = {}
  client_opts[:queue_url] = url
  client_opts[:entries] = entries

  response = client.send_message_batch(client_opts)

  failed = batch_failures(entries, response, true)

  checksum_failed = verify_send_message_batch_checksum entries, response

  sent = response[:successful].collect do |sent|
    msg = SentMessage.new
    msg.message_id = sent[:message_id]
    msg.md5 = sent[:md5_of_message_body]
    msg
  end

  if !failed.empty? && !checksum_failed.empty?
    send_error = Errors::BatchSendError.new(sent, failed)
    checksum_error = Errors::ChecksumError.new(checksum_failed)
    raise Errors::BatchSendMultiError.new send_error, checksum_error
  elsif !failed.empty?
    raise Errors::BatchSendError.new(sent, failed) unless failed.empty?
  elsif !checksum_failed.empty?
    raise Errors::ChecksumError.new(checksum_failed)
  end

  sent

end
created_timestamp() click to toggle source

@return [Time] The time when the queue was created.

# File lib/aws/sqs/queue.rb, line 356
def created_timestamp
  Time.at(get_attribute("CreatedTimestamp").to_i)
end
delay_seconds() click to toggle source

@return [Integer] Gets the current default delay for messages sent

to the queue.
# File lib/aws/sqs/queue.rb, line 402
def delay_seconds
  get_attribute("DelaySeconds").to_i
end
delay_seconds=(seconds) click to toggle source

Sets the default delay for messages sent to the queue. @param [Integer] seconds How many seconds a message will be delayed.

# File lib/aws/sqs/queue.rb, line 408
def delay_seconds= seconds
  set_attribute("DelaySeconds", seconds.to_s)
end
delete() click to toggle source

Deletes the queue, regardless of whether it is empty.

When you delete a queue, the deletion process takes up to 60 seconds. Requests you send involving that queue during the 60 seconds might succeed. For example, calling {#send_message} might succeed, but after the 60 seconds, the queue and that message you sent no longer exist.

Also, when you delete a queue, you must wait at least 60 seconds before creating a queue with the same name. @return [nil]

# File lib/aws/sqs/queue.rb, line 67
def delete
  client.delete_queue(:queue_url => url)
  nil
end
eql?(other)
Alias for: ==
exists?() click to toggle source

@return [Boolean] True if the queue exists.

@note This may raise an exception if you don’t have

permission to access the queue attributes.  Also, it may
return true for up to 60 seconds after a queue has been
deleted.
# File lib/aws/sqs/queue.rb, line 443
def exists?
  client.get_queue_attributes(:queue_url => url,
                              :attribute_names => ["QueueArn"])
rescue Errors::NonExistentQueue, Errors::InvalidAddress
  false
else
  true
end
inspect() click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 690
def inspect
  "<#{self.class}:#{url}>"
end
invisible_messages()
last_modified_timestamp() click to toggle source

@return [Time] The time when the queue was last changed.

# File lib/aws/sqs/queue.rb, line 361
def last_modified_timestamp
  Time.at(get_attribute("LastModifiedTimestamp").to_i)
end
maximum_message_size() click to toggle source

@return [Integer] The limit of how many bytes a message can

contain before Amazon SQS rejects it.
# File lib/aws/sqs/queue.rb, line 367
def maximum_message_size
  get_attribute("MaximumMessageSize").to_i
end
maximum_message_size=(size) click to toggle source

Sets the maximum message size for the queue.

@param [Integer] size The limit of how many bytes a message

can contain before Amazon SQS rejects it.  This must be an
integer from 1024 bytes (1KB) up to 65536 bytes
(64KB). The default for this attribute is 8192 (8KB).

@return Retuns the passed size argument.

# File lib/aws/sqs/queue.rb, line 378
def maximum_message_size=(size)
  set_attribute("MaximumMessageSize", size.to_s)
end
message_retention_period() click to toggle source

@return [Integer] The number of seconds Amazon SQS retains a

message.
# File lib/aws/sqs/queue.rb, line 384
def message_retention_period
  get_attribute("MessageRetentionPeriod").to_i
end
message_retention_period=(period) click to toggle source

Sets the message retention period for the queue

@param [Integer] period The number of seconds Amazon SQS

retains a message.  Must be an integer from 3600 (1 hour)
to 1209600 (14 days). The default for this attribute is
345600 (4 days).

@return Returns the passed period argument.

# File lib/aws/sqs/queue.rb, line 395
def message_retention_period=(period)
  set_attribute("MessageRetentionPeriod", period.to_s)
  period
end
policy() click to toggle source

@return [Policy] Returns the current queue policy if there is one.

Returns `nil` otherwise.
# File lib/aws/sqs/queue.rb, line 470
def policy
  if policy_json = get_attribute('Policy')
    policy = SQS::Policy.from_json(policy_json)
    policy.extend(PolicyProxy)
    policy.queue = self
    policy
  else
    nil
  end
end
policy=(policy) click to toggle source

Set the policy on this queue.

If you pass nil or an empty string then it will have the same effect as deleting the policy.

@param policy The policy to set. This policy can be a {Policy} object,

a json policy string, or any other object that responds with a policy
string when it received #to_json.

@return [nil]

# File lib/aws/sqs/queue.rb, line 492
def policy= policy
  policy_string = case policy
  when nil, '' then ''
  when String  then policy
  else policy.to_json
  end
  set_attribute('Policy', policy_string)
  nil
end
poll(opts = {}) { |message| ... } click to toggle source

Polls continually for messages. For example, you can use this to poll indefinitely:

queue.poll { |msg| puts msg.body }

Or, to poll indefinitely for the first message and then continue polling until no message is received for a period of at least ten seconds:

queue.poll(:initial_timeout => false,
           :idle_timeout => 10) { |msg| puts msg.body }

As with the block form of {#receive_message}, this method automatically deletes the message then the block exits normally.

@yieldparam [ReceivedMessage] message Each message that was received.

@param [Hash] opts Options for polling.

@option opts [Integer] :wait_time_seconds The number of seconds

the service should wait for a response when requesting a new message.
Defaults to {DEFAULT_WAIT_TIME_SECONDS}. Use `nil` to
use the queue's global long polling wait time setting.
See {#wait_time_seconds} to set the global long poll setting
on the queue.

@option opts [Integer] :idle_timeout The maximum number of

seconds to spend polling while no messages are being
returned.  By default this method polls indefinitely
whether messages are received or not.

@option opts [Integer] :initial_timeout The maximum number

of seconds to spend polling before the first message is
received.  This option defaults to the value of
`:idle_timeout`.  You can specify `false` to poll
indefinitely for the first message when `:idle_timeout` is
set.

@option opts [Integer] :batch_size The maximum number of

messages to retrieve in a single request.  By default
messages are received one at a time.  Valid values:
integers from 1 to 10.

@option opts [Integer] :visibility_timeout The duration (in

seconds) that the received messages are hidden from
subsequent retrieve requests.  Valid values: integer from
0 to 43200 (maximum 12 hours)

@option opts [Array<Symbol, String>] :attributes The

attributes to populate in each received message.  Valid values:

* `:all` (to populate all attributes)
* `:sender_id`
* `:sent_at`
* `:receive_count`
* `:first_received_at`

See {ReceivedMessage} for documentation on each
attribute's meaning.

@option opts [Float, Integer] :poll_interval As of

v1.7.2, this option is no longer used. See the
`:wait_time_seconds` option for long polling instead.

@return [nil]

# File lib/aws/sqs/queue.rb, line 292
def poll(opts = {}, &block)
  opts[:limit] = opts.delete(:batch_size) if
    opts.key?(:batch_size)

  opts[:wait_time_seconds] = DEFAULT_WAIT_TIME_SECONDS unless
    opts.has_key?(:wait_time_seconds)

  last_message_at = Time.now
  got_first = false
  loop do
    got_msg = false
    receive_messages(opts) do |message|
      got_msg = got_first = true
      last_message_at = Time.now
      yield(message)
    end
    unless got_msg
      return if hit_timeout?(got_first, last_message_at, opts)
    end
  end
  nil
end
receive_message(opts = {}, &block) click to toggle source

Retrieves one or more messages. When a block is given, each message is yielded to the block and then deleted as long as the block exits normally. When no block is given, you must delete the message yourself using {ReceivedMessage#delete}.

@note Due to the distributed nature of the queue, a weighted

random set of machines is sampled on a ReceiveMessage
call. That means only the messages on the sampled machines
are returned. If the number of messages in the queue is
small (less than 1000), it is likely you will get fewer
messages than you requested per call to
{#receive_message}. If the number of messages in the queue
is extremely small, you might not receive any messages.
To poll continually for messages, use the {#poll} method,
which automatically retries the request after a
configurable delay.

@param [Hash] opts Options for receiving messages.

@option opts [Integer] :limit The maximum number of messages

to receive.  By default this is 1, and the return value is
a single message object.  If this options is specified and
is not 1, the return value is an array of message objects;
however, the array may contain fewer objects than you
requested.  Valid values: integers from 1 to 10.

Not necessarily all the messages in the queue are returned
(for more information, see the preceding note about
machine sampling).

@option opts [Integer] :wait_time_seconds The number of seconds

the service should wait for a response when requesting a new message.
Defaults to the {#wait_time_seconds} attribute defined on the queue.
See {#wait_time_seconds} to set the global long poll setting
on the queue.

@option opts [Integer] :visibility_timeout The duration (in

seconds) that the received messages are hidden from
subsequent retrieve requests.  Valid values: integer from
0 to 43200 (maximum 12 hours)

@option opts [Array<Symbol, String>] :attributes The

attributes to populate in each received message.  Valid values:

* `:all` (to populate all attributes)
* `:sender_id`
* `:sent_at`
* `:receive_count`
* `:first_received_at`

See {ReceivedMessage} for documentation on each
attribute's meaning.

@option opts [Array<String>] :message_attribute_names A list of

message attribute names to receive. These will be available on
the {ReceivedMessage} as `#message_attributes`.

@yieldparam [ReceivedMessage] message Each message that was received.

@return [ReceivedMessage] Returns the received message (or messages)

only if a block is not given to this method.
# File lib/aws/sqs/queue.rb, line 200
def receive_message(opts = {}, &block)
  resp = client.receive_message(receive_opts(opts))

  failed = verify_receive_message_checksum resp

  raise Errors::ChecksumError.new(failed) unless failed.empty?

  messages = resp[:messages].map do |m|
    ReceivedMessage.new(self, m[:message_id], m[:receipt_handle],
      :body => m[:body],
      :md5 => m[:md5_of_body],
      :request_id => (resp[:response_metadata] || {})[:request_id],
      :attributes => m[:attributes],
      :message_attributes => m[:message_attributes])
  end

  if block
    call_message_block(messages, block)
  elsif opts[:limit] && opts[:limit] != 1
    messages
  else
    messages.first
  end
end
Also aliased as: receive_messages
receive_messages(opts = {}, &block)
Alias for: receive_message
send_message(body, options = {}) click to toggle source

Delivers a message to this queue.

@param [String] body The message to send. The maximum

allowed message size is 64 KB.  The message may only
contain Unicode characters from the following list,
according to the W3C XML specification (for more
information, go to
http://www.w3.org/TR/REC-xml/#charsets).  If you send any
characters not included in the list, your request will be
rejected.

* `#x9`
* `#xA`
* `#xD`
* `#x20` to `#xD7FF`
* `#xE000` to `#xFFFD`
* `#x10000` to `#x10FFFF`

@param [Hash] options

@option options [Integer] :delay_seconds The number of seconds to

delay the message. The message will become available for
processing after the delay time has passed.
If you don't specify a value, the default value for the
queue applies.  Should be from 0 to 900 (15 mins).

@return [SentMessage] An object containing information about

the message that was sent.
# File lib/aws/sqs/queue.rb, line 119
def send_message body, options = {}

  client_opts = options.dup
  client_opts[:queue_url] = url
  client_opts[:message_body] = body

  response = client.send_message(client_opts)

  msg = SentMessage.new
  msg.message_id = response[:message_id]
  msg.request_id = (response[:response_metadata] || {})[:request_id]
  msg.md5 = response[:md5_of_message_body]

  verify_send_message_checksum body, msg.md5

  msg

end
visibility_timeout() click to toggle source

@return [Integer] Returns the visibility timeout for the

queue. For more information about visibility timeout, see
[Visibility Timeout](http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/IntroductionArticle.html#AboutVT)
in the Amazon SQS Developer Guide.
# File lib/aws/sqs/queue.rb, line 337
def visibility_timeout
  get_attribute("VisibilityTimeout").to_i
end
visibility_timeout=(timeout) click to toggle source

Sets the visibility timeout for the queue.

@param [Integer] timeout The length of time (in seconds)

that a message received from a queue will be invisible to
other receiving components when they ask to receive
messages.  Valid values: integers from 0 to 43200 (12
hours).

@return Returns the value passed as a timeout.

# File lib/aws/sqs/queue.rb, line 350
def visibility_timeout=(timeout)
  set_attribute("VisibilityTimeout", timeout.to_s)
  timeout
end
visible_messages()
wait_time_seconds() click to toggle source

@return [Integer] Gets the number of seconds the service will wait

for a response when requesting a new message

@since 1.8.0

# File lib/aws/sqs/queue.rb, line 415
def wait_time_seconds
  get_attribute("ReceiveMessageWaitTimeSeconds").to_i
end
wait_time_seconds=(seconds) click to toggle source

Sets the number of seconds that the service should wait for a response when requesting a new message @param [Integer] seconds How many seconds to wait for a response @since 1.8.0

# File lib/aws/sqs/queue.rb, line 423
def wait_time_seconds= seconds
  set_attribute("ReceiveMessageWaitTimeSeconds", seconds.to_s)
end

Protected Instance Methods

batch_failures(entries, response, include_batch_index=false) click to toggle source
# File lib/aws/sqs/queue.rb, line 695
def batch_failures entries, response, include_batch_index=false
  response[:failed].inject([]) do |failures, failure|

    entry = entries.find{|e| e[:id] == failure[:id] }

    details = {
      :error_code => failure[:code],
      :error_message => failure[:message],
      :sender_fault => failure[:sender_fault],
    }

    if include_batch_index
      details[:batch_index] = failure[:id].to_i
    end

    if message_body = entry[:message_body]
      details[:message_body] = message_body
    end

    if handle = entry[:receipt_handle]
      details[:receipt_handle] = handle
    end

    failures << details

  end
end
calculate_checksum(data) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 812
def calculate_checksum data
  OpenSSL::Digest::MD5.hexdigest data
end
call_message_block(messages, block) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 767
def call_message_block(messages, block)
  result = nil
  messages.each do |message|
    begin
      result = block.call(message)
    rescue Exception => e
      raise
    else
      message.delete
    end
  end
  result
end
get_attribute(name) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 783
def get_attribute(name)
  resp = client.get_queue_attributes(:queue_url => url,
                                     :attribute_names =>
                                     [name, "QueueArn"].uniq)
  @arn ||= resp.attributes["QueueArn"]
  resp.attributes[name]
end
hit_timeout?(got_first, last_message_at, opts) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 725
def hit_timeout?(got_first, last_message_at, opts)
  initial_timeout = opts[:initial_timeout]
  idle_timeout = opts[:idle_timeout]

  timeout = (got_first ||
             # if initial_timeout is false (as opposed
             # to nil) then we skip the branch and poll
             # indefinitely until the first message
             # comes
             (!initial_timeout && initial_timeout != false) ?
             idle_timeout :
             initial_timeout) and
    Time.now - last_message_at > timeout
end
is_checksum_valid(checksum, data) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 802
def is_checksum_valid checksum, data
  if config.sqs_verify_checksums?
    calculate_checksum(data) == checksum
  else
    true
  end
end
receive_opts(opts) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 742
def receive_opts(opts)
  receive_opts = { :queue_url => url }
  receive_opts[:visibility_timeout] = opts[:visibility_timeout] if
    opts[:visibility_timeout]
  receive_opts[:max_number_of_messages] = opts[:limit] if
    opts[:limit]
  receive_opts[:wait_time_seconds] = opts[:wait_time_seconds] if
    opts[:wait_time_seconds]
  receive_opts[:message_attribute_names] = opts[:message_attribute_names] if
    opts[:message_attribute_names]

  if names = opts[:attributes]
    receive_opts[:attribute_names] = names.map do |name|
      name = ReceivedMessage::ATTRIBUTE_ALIASES[name.to_sym] if
        ReceivedMessage::ATTRIBUTE_ALIASES.key?(name.to_sym)
      name = Core::Inflection.class_name(name.to_s) if name.kind_of?(Symbol)
      name
    end
  end

  receive_opts
end
set_attribute(name, value) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 793
def set_attribute(name, value)
  client.set_queue_attributes({
    :queue_url => url,
    :attributes => { name => value },
  })
end
verify_receive_message_checksum(response) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 839
def verify_receive_message_checksum response
  return [] if response[:messages].nil?

  invalid_msgs = []

  response[:messages].each do |msg|
    md5 = msg[:md5_of_body]
    body = msg[:body]
    invalid_msgs << msg unless is_checksum_valid md5, body
  end

  invalid_msgs
end
verify_send_message_batch_checksum(entries, response) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 826
def verify_send_message_batch_checksum entries, response
  failed = []

  response[:successful].each do |msg|
    entry = entries.find{ |e| e[:id] == msg[:id] }
    failed << msg unless is_checksum_valid msg[:md5_of_message_body], entry[:message_body]
  end

  failed
end
verify_send_message_checksum(body, md5) click to toggle source

@api private

# File lib/aws/sqs/queue.rb, line 818
def verify_send_message_checksum body, md5
  unless is_checksum_valid md5, body
    raise Errors::ChecksumError.new "Invalid MD5 #{md5} for message body #{body}"
  end
end