aws-sdk-sqs 1.67.0 → 1.89.0

data/lib/aws-sdk-sqs/endpoint_parameters.rb

@@ -52,15 +52,18 @@ module Aws::SQS
       self[:region] = options[:region]
       self[:use_dual_stack] = options[:use_dual_stack]
       self[:use_dual_stack] = false if self[:use_dual_stack].nil?
-      if self[:use_dual_stack].nil?
-        raise ArgumentError, "Missing required EndpointParameter: :use_dual_stack"
-      end
       self[:use_fips] = options[:use_fips]
       self[:use_fips] = false if self[:use_fips].nil?
-      if self[:use_fips].nil?
-        raise ArgumentError, "Missing required EndpointParameter: :use_fips"
-      end
       self[:endpoint] = options[:endpoint]
     end
+
+    def self.create(config, options={})
+      new({
+        region: config.region,
+        use_dual_stack: config.use_dualstack_endpoint,
+        use_fips: config.use_fips_endpoint,
+        endpoint: (config.endpoint.to_s unless config.regional_endpoint),
+      }.merge(options))
+    end
   end
 end

data/lib/aws-sdk-sqs/endpoints.rb

@@ -12,327 +12,9 @@ module Aws::SQS
   # @api private
   module Endpoints
 
-    class AddPermission
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class CancelMessageMoveTask
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class ChangeMessageVisibility
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class ChangeMessageVisibilityBatch
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class CreateQueue
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class DeleteMessage
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class DeleteMessageBatch
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class DeleteQueue
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class GetQueueAttributes
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class GetQueueUrl
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class ListDeadLetterSourceQueues
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class ListMessageMoveTasks
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class ListQueueTags
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class ListQueues
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class PurgeQueue
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class ReceiveMessage
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class RemovePermission
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
 
-    class SendMessage
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
+    def self.parameters_for_operation(context)
+      Aws::SQS::EndpointParameters.create(context.config)
     end
-
-    class SendMessageBatch
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class SetQueueAttributes
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class StartMessageMoveTask
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class TagQueue
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
-    class UntagQueue
-      def self.build(context)
-        unless context.config.regional_endpoint
-          endpoint = context.config.endpoint.to_s
-        end
-        Aws::SQS::EndpointParameters.new(
-          region: context.config.region,
-          use_dual_stack: context.config.use_dualstack_endpoint,
-          use_fips: context.config.use_fips_endpoint,
-          endpoint: endpoint,
-        )
-      end
-    end
-
   end
 end

data/lib/aws-sdk-sqs/message.rb

@@ -163,7 +163,7 @@ module Aws::SQS
         queue_url: @queue_url,
         receipt_handle: @receipt_handle
       )
-      resp = Aws::Plugins::UserAgent.feature('resource') do
+      resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
         @client.change_message_visibility(options)
       end
       resp.data
@@ -179,7 +179,7 @@ module Aws::SQS
         queue_url: @queue_url,
         receipt_handle: @receipt_handle
       )
-      resp = Aws::Plugins::UserAgent.feature('resource') do
+      resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
         @client.delete_message(options)
       end
       resp.data
@@ -246,7 +246,7 @@ module Aws::SQS
               receipt_handle: item.receipt_handle
             }
           end
-          Aws::Plugins::UserAgent.feature('resource') do
+          Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
             batch[0].client.delete_message_batch(params)
           end
         end

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

@@ -14,35 +14,49 @@ module Aws::SQS
       option(
         :endpoint_provider,
         doc_type: 'Aws::SQS::EndpointProvider',
-        docstring: 'The endpoint provider used to resolve endpoints. Any '\
-                   'object that responds to `#resolve_endpoint(parameters)` '\
-                   'where `parameters` is a Struct similar to '\
-                   '`Aws::SQS::EndpointParameters`'
-      ) do |cfg|
+        rbs_type: 'untyped',
+        docstring: <<~DOCS) do |_cfg|
+The endpoint provider used to resolve endpoints. Any object that responds to
+`#resolve_endpoint(parameters)` where `parameters` is a Struct similar to
+`Aws::SQS::EndpointParameters`.
+        DOCS
         Aws::SQS::EndpointProvider.new
       end
 
       # @api private
       class Handler < Seahorse::Client::Handler
         def call(context)
-          # If endpoint was discovered, do not resolve or apply the endpoint.
           unless context[:discovered_endpoint]
-            params = parameters_for_operation(context)
+            params = Aws::SQS::Endpoints.parameters_for_operation(context)
             endpoint = context.config.endpoint_provider.resolve_endpoint(params)
 
             context.http_request.endpoint = endpoint.url
             apply_endpoint_headers(context, endpoint.headers)
+
+            context[:endpoint_params] = params
+            context[:endpoint_properties] = endpoint.properties
           end
 
-          context[:endpoint_params] = params
           context[:auth_scheme] =
             Aws::Endpoints.resolve_auth_scheme(context, endpoint)
 
-          @handler.call(context)
+          with_metrics(context) { @handler.call(context) }
         end
 
         private
 
+        def with_metrics(context, &block)
+          metrics = []
+          metrics << 'ENDPOINT_OVERRIDE' unless context.config.regional_endpoint
+          if context[:auth_scheme] && context[:auth_scheme]['name'] == 'sigv4a'
+            metrics << 'SIGV4A_SIGNING'
+          end
+          if context.config.credentials&.credentials&.account_id
+            metrics << 'RESOLVED_ACCOUNT_ID'
+          end
+          Aws::Plugins::UserAgent.metric(*metrics, &block)
+        end
+
         def apply_endpoint_headers(context, headers)
           headers.each do |key, values|
             value = values
@@ -53,57 +67,6 @@ module Aws::SQS
             context.http_request.headers[key] = value
           end
         end
-
-        def parameters_for_operation(context)
-          case context.operation_name
-          when :add_permission
-            Aws::SQS::Endpoints::AddPermission.build(context)
-          when :cancel_message_move_task
-            Aws::SQS::Endpoints::CancelMessageMoveTask.build(context)
-          when :change_message_visibility
-            Aws::SQS::Endpoints::ChangeMessageVisibility.build(context)
-          when :change_message_visibility_batch
-            Aws::SQS::Endpoints::ChangeMessageVisibilityBatch.build(context)
-          when :create_queue
-            Aws::SQS::Endpoints::CreateQueue.build(context)
-          when :delete_message
-            Aws::SQS::Endpoints::DeleteMessage.build(context)
-          when :delete_message_batch
-            Aws::SQS::Endpoints::DeleteMessageBatch.build(context)
-          when :delete_queue
-            Aws::SQS::Endpoints::DeleteQueue.build(context)
-          when :get_queue_attributes
-            Aws::SQS::Endpoints::GetQueueAttributes.build(context)
-          when :get_queue_url
-            Aws::SQS::Endpoints::GetQueueUrl.build(context)
-          when :list_dead_letter_source_queues
-            Aws::SQS::Endpoints::ListDeadLetterSourceQueues.build(context)
-          when :list_message_move_tasks
-            Aws::SQS::Endpoints::ListMessageMoveTasks.build(context)
-          when :list_queue_tags
-            Aws::SQS::Endpoints::ListQueueTags.build(context)
-          when :list_queues
-            Aws::SQS::Endpoints::ListQueues.build(context)
-          when :purge_queue
-            Aws::SQS::Endpoints::PurgeQueue.build(context)
-          when :receive_message
-            Aws::SQS::Endpoints::ReceiveMessage.build(context)
-          when :remove_permission
-            Aws::SQS::Endpoints::RemovePermission.build(context)
-          when :send_message
-            Aws::SQS::Endpoints::SendMessage.build(context)
-          when :send_message_batch
-            Aws::SQS::Endpoints::SendMessageBatch.build(context)
-          when :set_queue_attributes
-            Aws::SQS::Endpoints::SetQueueAttributes.build(context)
-          when :start_message_move_task
-            Aws::SQS::Endpoints::StartMessageMoveTask.build(context)
-          when :tag_queue
-            Aws::SQS::Endpoints::TagQueue.build(context)
-          when :untag_queue
-            Aws::SQS::Endpoints::UntagQueue.build(context)
-          end
-        end
       end
 
       def add_handlers(handlers, _config)

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