aws-sdk-sqs 1.30.0 → 1.89.0

data/lib/aws-sdk-sqs/plugins/md5s.rb

@@ -6,7 +6,6 @@ module Aws
   module SQS
     module Plugins
       class Md5s < Seahorse::Client::Plugin
-
         # @api private
         class Handler < Seahorse::Client::Handler
           def call(context)
@@ -26,16 +25,17 @@ module Aws
             'String' => 1,
             'Binary' => 2,
             'Number' => 1
-          }
+          }.freeze
 
-          DATA_TYPE = /\A(String|Binary|Number)(\..+)?\z/
+          DATA_TYPE = /\A(String|Binary|Number)(\..+)?\z/.freeze
 
           NORMALIZED_ENCODING = Encoding::UTF_8
 
           def validate_send_message(context, response)
             body = context.params[:message_body]
             attributes = context.params[:message_attributes]
-            validate_single_message(body, attributes, response)
+            system_attributes = context.params[:message_system_attributes]
+            validate_single_message(body, attributes, system_attributes, response)
           end
 
           def validate_send_message_batch(context, response)
@@ -43,63 +43,87 @@ module Aws
               id = entry[:id]
               body = entry[:message_body]
               attributes = entry[:message_attributes]
+              system_attributes = entry[:message_system_attributes]
               message_response = response.successful.select { |r| r.id == id }[0]
               unless message_response.nil?
-                validate_single_message(body, attributes, message_response)
+                validate_single_message(body, attributes, system_attributes, message_response)
               end
             end
           end
 
-          def validate_single_message(body, attributes, response)
+          def validate_single_message(body, attributes, system_attributes, response)
             validate_body(body, response)
             unless attributes.nil? || attributes.empty?
               validate_attributes(attributes, response)
             end
+            unless system_attributes.nil? || system_attributes.empty?
+              validate_system_attributes(system_attributes, response)
+            end
           end
 
           def validate_body(body, response)
             calculated_md5 = md5_of_message_body(body)
             returned_md5 = response.md5_of_message_body
-            if calculated_md5 != returned_md5
-              error_message =  mismatch_error_message(
-                'message body',
-                calculated_md5,
-                returned_md5,
-                response)
-              raise Aws::Errors::ChecksumError, error_message
-            end
+            return unless calculated_md5 != returned_md5
+
+            error_message = mismatch_error_message(
+              'message body',
+              calculated_md5,
+              returned_md5,
+              response
+            )
+            raise Aws::Errors::ChecksumError, error_message
           end
 
           def validate_attributes(attributes, response)
             calculated_md5 = md5_of_message_attributes(attributes)
             returned_md5 = response.md5_of_message_attributes
-            if returned_md5 != calculated_md5
-              error_message =  mismatch_error_message(
-                'message attributes',
-                calculated_md5,
-                returned_md5,
-                response)
-              raise Aws::Errors::ChecksumError, error_message
-            end
+            return unless returned_md5 != calculated_md5
+
+            error_message = mismatch_error_message(
+              'message attributes',
+              calculated_md5,
+              returned_md5,
+              response
+            )
+            raise Aws::Errors::ChecksumError, error_message
+          end
+
+          def validate_system_attributes(system_attributes, response)
+            calculated_md5 = md5_of_message_system_attributes(system_attributes)
+            returned_md5 = response.md5_of_message_system_attributes
+            return unless returned_md5 != calculated_md5
+
+            error_message = mismatch_error_message(
+              'message system attributes',
+              calculated_md5,
+              returned_md5,
+              response
+            )
+            raise Aws::Errors::ChecksumError, error_message
           end
 
           def md5_of_message_body(message_body)
             OpenSSL::Digest::MD5.hexdigest(message_body)
           end
 
+          # MD5 of Message Attributes and System Attributes are effectively
+          # the same calculation. However, keeping these as two methods because
+          # they are modeled as two different shapes.
+          ###
           def md5_of_message_attributes(message_attributes)
-            encoded = { }
+            encoded = {}
             message_attributes.each do |name, attribute|
               name = name.to_s
               encoded[name] = String.new
               data_type_without_label = DATA_TYPE.match(attribute[:data_type])[1]
               encoded[name] << encode_length_and_bytes(name) <<
-              encode_length_and_bytes(attribute[:data_type]) <<
-              [TRANSPORT_TYPE_ENCODINGS[data_type_without_label]].pack('C'.freeze)
+                encode_length_and_bytes(attribute[:data_type]) <<
+                [TRANSPORT_TYPE_ENCODINGS[data_type_without_label]].pack('C')
 
-              if attribute[:string_value] != nil
+              if !attribute[:string_value].nil?
                 encoded[name] << encode_length_and_string(attribute[:string_value])
-              elsif attribute[:binary_value] != nil
+              elsif !attribute[:binary_value].nil?
                 encoded[name] << encode_length_and_bytes(attribute[:binary_value])
               end
             end
@@ -110,6 +134,30 @@ module Aws
             OpenSSL::Digest::MD5.hexdigest(buffer)
           end
 
+          def md5_of_message_system_attributes(message_system_attributes)
+            encoded = {}
+            message_system_attributes.each do |name, attribute|
+              name = name.to_s
+              encoded[name] = String.new
+              data_type_without_label = DATA_TYPE.match(attribute[:data_type])[1]
+              encoded[name] << encode_length_and_bytes(name) <<
+                encode_length_and_bytes(attribute[:data_type]) <<
+                [TRANSPORT_TYPE_ENCODINGS[data_type_without_label]].pack('C')
+
+              if !attribute[:string_value].nil?
+                encoded[name] << encode_length_and_string(attribute[:string_value])
+              elsif !attribute[:binary_value].nil?
+                encoded[name] << encode_length_and_bytes(attribute[:binary_value])
+              end
+            end
+
+            buffer = encoded.keys.sort.reduce(String.new) do |string, name|
+              string << encoded[name]
+            end
+            OpenSSL::Digest::MD5.hexdigest(buffer)
+          end
+          ###
+
           def encode_length_and_string(string)
             string = String.new(string)
             string.encode!(NORMALIZED_ENCODING)
@@ -117,7 +165,7 @@ module Aws
           end
 
           def encode_length_and_bytes(bytes)
-            [bytes.bytesize, bytes].pack('L>a*'.freeze)
+            [bytes.bytesize, bytes].pack('L>a*')
           end
 
           def mismatch_error_message(section, local_md5, returned_md5, response)
@@ -154,13 +202,14 @@ not match.
         end
 
         def add_handlers(handlers, config)
-          if config.verify_checksums
-            handlers.add(Handler, {
-              priority: 10 ,
-              step: :validate,
-              operations: [:send_message, :send_message_batch]
-            })
-          end
+          return unless config.verify_checksums
+
+          handlers.add(
+            Handler,
+            priority: 10,
+            step: :validate,
+            operations: %i[send_message send_message_batch]
+          )
         end
       end
     end

data/lib/aws-sdk-sqs/plugins/queue_urls.rb

@@ -5,11 +5,10 @@ module Aws
     module Plugins
       # @api private
       class QueueUrls < Seahorse::Client::Plugin
-
+        # Extract region from a provided queue_url
         class Handler < Seahorse::Client::Handler
-
           def call(context)
-            if queue_url = context.params[:queue_url]
+            if (queue_url = context.params[:queue_url])
               update_endpoint(context, queue_url)
               update_region(context, queue_url)
             end
@@ -21,28 +20,31 @@ module Aws
           end
 
           # If the region in the queue url is not the configured
-          # region, then we will modify the request to have
-          # a sigv4 signer for the proper region.
+          # region, then we will modify signing to use it
           def update_region(context, queue_url)
-            if queue_region = parse_region(queue_url)
-              if queue_region != context.config.region
-                config = context.config.dup
-                config.region = queue_region
-                config.sigv4_region = queue_region
-                config.sigv4_signer = Aws::Plugins::SignatureV4.build_signer(config)
-                context.config = config
-              end
+            if (queue_region = parse_region(queue_url)) &&
+               queue_region != context.config.region
+              context[:auth_scheme]['signingRegion'] = queue_region
             end
           end
 
           private
 
-          # take the first component after service delimiter
-          # https://sqs.us-east-1.amazonaws.com/1234567890/demo
-          # https://vpce-x-y.sqs.us-east-1.vpce.amazonaws.com/1234567890/demo
+          # take the first component after the SQS service component
+          # Will return us-east-1 for:
+          #   https://sqs.us-east-1.amazonaws.com/1234567890/demo
+          #   https://vpce-x-y.sqs.us-east-1.vpce.amazonaws.com/1234567890/demo
+          # Will not return for:
+          #   https://localstack-sqs.example.dev/queue/example
           def parse_region(url)
-            parts = url.split('sqs.')
-            parts[1].split('.').first if parts.size > 1
+            parts = URI.parse(url).host.split('.')
+            parts.each_with_index do |part, index|
+              if part == 'sqs'
+                # assume region is the part right after the 'sqs' part
+                return parts[index + 1]
+              end
+            end
+            nil # no region found
           end
 
         end