aws-sdk-core 2.11.366 → 3.67.0

data/lib/aws-sdk-core/pager.rb

@@ -1,14 +1,16 @@
+require 'jmespath'
+
 module Aws
   # @api private
   class Pager
 
-    def initialize(rules)
-      @more_results = rules['more_results']
-      @more_results = underscore(@more_results) if @more_results
-      if rules['limit_key']
-        @limit_key = underscore(rules['limit_key']).to_sym
-      end
-      map_tokens(rules)
+    # @option options [required, Hash<JMESPath,JMESPath>] :tokens
+    # @option options [String<JMESPath>] :limit_key
+    # @option options [String<JMESPath>] :more_results
+    def initialize(options)
+      @tokens = options.fetch(:tokens)
+      @limit_key = options.fetch(:limit_key, nil)
+      @more_results = options.fetch(:more_results, nil)
     end
 
     # @return [Symbol, nil]
@@ -37,32 +39,35 @@ module Aws
       if @more_results
         JMESPath.search(@more_results, response.data)
       else
-        next_tokens = self.next_tokens(response)
-        prev_tokens = self.prev_tokens(response)
-        !(next_tokens.empty? || next_tokens == prev_tokens)
+        next_t = next_tokens(response)
+        prev_t = prev_tokens(response)
+        !(next_t.empty? || next_t == prev_t)
       end
     end
 
     private
 
-    def map_tokens(rules)
-      input = Array(rules['input_token'])
-      output = Array(rules['output_token'])
-      @tokens = {}
-      input.each.with_index do |key, n|
-        @tokens[underscore(output[n])] = underscore(key)
-      end
-    end
-
-    def underscore(str)
-      str.
-        gsub(' or ', '||').
-        gsub(/\w+/) { |part| Seahorse::Util.underscore(part) }
-    end
-
     def empty_value?(value)
       value.nil? || value == '' || value == [] || value == {}
     end
 
+    class NullPager
+
+      # @return [nil]
+      attr_reader :limit_key
+
+      def next_tokens
+        {}
+      end
+
+      def prev_tokens
+        {}
+      end
+
+      def truncated?(response)
+        false
+      end
+
+    end
   end
 end

data/lib/aws-sdk-core/param_converter.rb

@@ -40,7 +40,7 @@ module Aws
 
     def structure(ref, values)
       values = c(ref, values)
-      if Struct === values || Hash === values
+      if ::Struct === values || Hash === values
         values.each_pair do |k, v|
           unless v.nil?
             if ref.shape.member?(k)
@@ -165,10 +165,10 @@ module Aws
     end
 
     add(StructureShape, Hash) { |h| h.dup }
-    add(StructureShape, Struct)
+    add(StructureShape, ::Struct)
 
     add(MapShape, Hash) { |h| h.dup }
-    add(MapShape, Struct) do |s|
+    add(MapShape, ::Struct) do |s|
       s.members.each.with_object({}) {|k,h| h[k] = s[k] }
     end
 

data/lib/aws-sdk-core/param_validator.rb

@@ -16,8 +16,13 @@ module Aws
     # @param [Seahorse::Model::Shapes::ShapeRef] rules
     # @option options [Boolean] :validate_required (true)
     def initialize(rules, options = {})
-      @rules = rules
+      @rules = rules || begin
+        shape = StructureShape.new
+        shape.struct_class = EmptyStructure
+        ShapeRef.new(shape: shape)
+      end
       @validate_required = options[:validate_required] != false
+      @input = options[:input].nil? ? true : !!options[:input]
     end
 
     # @param [Hash] params
@@ -34,28 +39,50 @@ module Aws
       # ensure the value is hash like
       return unless correct_type?(ref, values, errors, context)
 
-      shape = ref.shape
-
-      # ensure required members are present
-      if @validate_required
-        shape.required.each do |member_name|
-          if values[member_name].nil?
-            param = "#{context}[#{member_name.inspect}]"
-            errors << "missing required parameter #{param}"
+      if ref.eventstream
+        # input eventstream is provided from event signals
+        values.each do |value|
+          # each event is structure type
+          case value[:message_type]
+          when 'event'
+            val = value.dup
+            val.delete(:message_type)
+            structure(ref.shape.member(val[:event_type]), val, errors, context)
+          when 'error' # Error is unmodeled
+          when 'exception' # Pending
+            raise Aws::Errors::EventStreamParserError.new(
+              ':exception event validation is not supported')
+          end
+        end
+      else
+        shape = ref.shape
+
+        # ensure required members are present
+        if @validate_required
+          shape.required.each do |member_name|
+            input_eventstream = ref.shape.member(member_name).eventstream && @input
+            if values[member_name].nil? && !input_eventstream
+              param = "#{context}[#{member_name.inspect}]"
+              errors << "missing required parameter #{param}"
+            end
           end
         end
-      end
 
-      # validate non-nil members
-      values.each_pair do |name, value|
-        unless value.nil?
-          if shape.member?(name)
-            member_ref = shape.member(name)
-            shape(member_ref, value, errors, context + "[#{name.inspect}]")
-          else
-            errors << "unexpected value at #{context}[#{name.inspect}]"
+        # validate non-nil members
+        values.each_pair do |name, value|
+          unless value.nil?
+            # :event_type is not modeled
+            # and also needed when construct body
+            next if name == :event_type
+            if shape.member?(name)
+              member_ref = shape.member(name)
+              shape(member_ref, value, errors, context + "[#{name.inspect}]")
+            else
+              errors << "unexpected value at #{context}[#{name.inspect}]"
+            end
           end
         end
+
       end
     end
 
@@ -74,8 +101,10 @@ module Aws
     end
 
     def map(ref, values, errors, context)
-
-      return unless correct_type?(ref, values, errors, context)
+      unless Hash === values
+        errors << expected_got(context, "a hash", values)
+        return
+      end
 
       key_ref = ref.shape.key
       value_ref = ref.shape.value
@@ -121,9 +150,15 @@ module Aws
     end
 
     def correct_type?(ref, value, errors, context)
+      if ref.eventstream && @input
+        errors << "instead of providing value directly for eventstreams at input,"\
+          " expected to use #signal events per stream"
+        return false
+      end
       case value
       when Hash then true
-      when ref[:struct_class] then true
+      when ref.shape.struct_class then true
+      when Enumerator then ref.eventstream && value.respond_to?(:event_types)
       else
         errors << expected_got(context, "a hash", value)
         false

data/lib/aws-sdk-core/plugins/api_key.rb

@@ -0,0 +1,52 @@
+module Aws
+  module Plugins
+
+    # Provide support for `api_key` parameter for `api-gateway` protocol
+    # specific `api-gateway` protocol gems' user-agent
+    class ApiKey < Seahorse::Client::Plugin
+
+      option(:api_key,
+        default: nil,
+        doc_type: 'String',
+        docstring: <<-DOCS)
+When provided, `x-api-key` header will be injected with the value provided.
+        DOCS
+
+      def add_handlers(handlers, config)
+        handlers.add(OptionHandler, step: :initialize)
+        handlers.add(ApiKeyHandler, step: :build, priority: 0)
+      end
+
+      # @api private
+      class OptionHandler < Seahorse::Client::Handler
+        def call(context)
+          if context.operation.require_apikey
+            api_key = context.params.delete(:api_key)
+            api_key = context.config.api_key if api_key.nil?
+            context[:api_key] = api_key
+          end
+
+          @handler.call(context)
+        end
+
+      end
+
+      # @api private
+      class ApiKeyHandler < Seahorse::Client::Handler
+
+        def call(context)
+          if context[:api_key]
+            apply_api_key(context)
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def apply_api_key(context)
+          context.http_request.headers['x-api-key'] = context[:api_key]
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/apig_authorizer_token.rb

@@ -0,0 +1,30 @@
+module Aws
+  module Plugins
+
+    # apply APIG custom authorizer token to
+    # operations with 'authtype' of 'custom' only
+    class APIGAuthorizerToken < Seahorse::Client::Plugin
+
+      option(:authorizer_token, default: nil)
+
+      def add_handlers(handlers, config)
+        handlers.add(AuthTokenHandler, step: :sign)
+      end
+
+      # @api private
+      class AuthTokenHandler < Seahorse::Client::Handler
+
+        def call(context)
+          if context.operation['authtype'] == 'custom' &&
+            context.config.authorizer_token &&
+            context.authorizer.placement[:location] == 'header'
+
+            header = context.authorizer.placement[:name]
+            context.http_request.headers[header] = context.config.authorizer_token
+          end
+          @handler.call(context)
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/apig_credentials_configuration.rb

@@ -0,0 +1,34 @@
+module Aws
+  # @api private
+  module Plugins
+    # @api private
+    # Used for APIGateway generated SDKs credentials config
+    class APIGCredentialsConfiguration < Seahorse::Client::Plugin
+
+      option(:access_key_id, doc_type: String, docstring: '')
+
+      option(:secret_access_key, doc_type: String, docstring: '')
+
+      option(:session_token, doc_type: String, docstring: '')
+
+      option(:profile, doc_type: String, docstring: '')
+
+      option(:credentials,
+        required: false,
+        doc_type: 'Aws::CredentialProvider',
+        docstring: <<-DOCS
+AWS Credentials options is only required when your API uses 
+[AWS Signature Version 4](http://docs.aws.amazon.com/general/latest/gr/signature-version-4.html),
+more AWS Credentials Configuration Options are available [here](https://github.com/aws/aws-sdk-ruby#configuration).
+        DOCS
+      ) do |config|
+        CredentialProviderChain.new(config).resolve
+      end
+
+      option(:instance_profile_credentials_retries, 0)
+
+      option(:instance_profile_credentials_timeout, 1)
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/apig_user_agent.rb

@@ -0,0 +1,37 @@
+module Aws
+  module Plugins
+    # @api private
+    class APIGUserAgent < Seahorse::Client::Plugin
+
+      option(:user_agent_suffix)
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          set_user_agent(context)
+          @handler.call(context)
+        end
+
+        def set_user_agent(context)
+          ua = "aws-apig-ruby/#{CORE_GEM_VERSION}"
+
+          begin
+            ua += " #{RUBY_ENGINE}/#{RUBY_VERSION}"
+          rescue
+            ua += " RUBY_ENGINE_NA/#{RUBY_VERSION}"
+          end
+
+          ua += " #{RUBY_PLATFORM}"
+          ua += " #{context.config.user_agent_suffix}" if context.config.user_agent_suffix
+
+          context.http_request.headers['User-Agent'] = ua.strip
+        end
+
+      end
+
+      handler(Handler)
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/client_metrics_plugin.rb

@@ -0,0 +1,280 @@
+require 'date'
+
+module Aws
+  module Plugins
+    class ClientMetricsPlugin < Seahorse::Client::Plugin
+
+      option(:client_side_monitoring,
+        default: false,
+        doc_type: 'Boolean',
+        docstring: <<-DOCS) do |cfg|
+When `true`, client-side metrics will be collected for all API requests from
+this client.
+      DOCS
+        resolve_client_side_monitoring(cfg)
+      end
+
+      option(:client_side_monitoring_port,
+        default: 31000,
+        doc_type: Integer,
+        docstring: <<-DOCS) do |cfg|
+Required for publishing client metrics. The port that the client side monitoring
+agent is running on, where client metrics will be published via UDP.
+      DOCS
+        resolve_client_side_monitoring_port(cfg)
+      end
+
+      option(:client_side_monitoring_host,
+        default: "127.0.0.1",
+        doc_type: String,
+        docstring: <<-DOCS) do |cfg|
+Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client
+side monitoring agent is running on, where client metrics will be published via UDP.
+      DOCS
+        resolve_client_side_monitoring_host(cfg)
+      end
+
+      option(:client_side_monitoring_publisher,
+        default: ClientSideMonitoring::Publisher,
+        doc_type: Aws::ClientSideMonitoring::Publisher,
+        docstring: <<-DOCS) do |cfg|
+Allows you to provide a custom client-side monitoring publisher class. By default,
+will use the Client Side Monitoring Agent Publisher.
+      DOCS
+        resolve_publisher(cfg)
+      end
+
+      option(:client_side_monitoring_client_id,
+        default: "",
+        doc_type: String,
+        docstring: <<-DOCS) do |cfg|
+Allows you to provide an identifier for this client which will be attached to
+all generated client side metrics. Defaults to an empty string.
+        DOCS
+        resolve_client_id(cfg)
+      end
+
+      def add_handlers(handlers, config)
+        if config.client_side_monitoring && config.client_side_monitoring_port
+          handlers.add(Handler, step: :initialize)
+          publisher = config.client_side_monitoring_publisher
+          publisher.agent_port = config.client_side_monitoring_port
+          publisher.agent_host = config.client_side_monitoring_host
+        end
+      end
+
+      private
+      def self.resolve_publisher(cfg)
+        ClientSideMonitoring::Publisher.new
+      end
+
+      def self.resolve_client_side_monitoring_port(cfg)
+        env_source = ENV["AWS_CSM_PORT"]
+        env_source = nil if env_source == ""
+        cfg_source = Aws.shared_config.csm_port(profile: cfg.profile)
+        if env_source
+          env_source.to_i
+        elsif cfg_source
+          cfg_source.to_i
+        else
+          31000
+        end
+      end
+
+      def self.resolve_client_side_monitoring_host(cfg)
+        env_source = ENV["AWS_CSM_HOST"]
+        env_source = nil if env_source == ""
+        cfg_source = Aws.shared_config.csm_host(profile: cfg.profile)
+        if env_source
+          env_source
+        elsif cfg_source
+          cfg_source
+        else
+          "127.0.0.1"
+        end
+      end
+
+      def self.resolve_client_side_monitoring(cfg)
+        env_source = ENV["AWS_CSM_ENABLED"]
+        env_source = nil if env_source == ""
+        if env_source.is_a?(String) && (env_source.downcase == "false" || env_source.downcase == "f")
+          env_source = false
+        end
+        cfg_source = Aws.shared_config.csm_enabled(profile: cfg.profile)
+        if env_source || cfg_source
+          true
+        else
+          false
+        end
+      end
+
+      def self.resolve_client_id(cfg)
+        default = ""
+        env_source = ENV["AWS_CSM_CLIENT_ID"]
+        env_source = nil if env_source == ""
+        cfg_source = Aws.shared_config.csm_client_id(profile: cfg.profile)
+        env_source || cfg_source || default
+      end
+
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          publisher = context.config.client_side_monitoring_publisher
+          service_id = context.config.api.metadata["serviceId"]
+          # serviceId not present in all versions, need a fallback
+          service_id ||= _calculate_service_id(context)
+
+          request_metrics = ClientSideMonitoring::RequestMetrics.new(
+            service: service_id,
+            operation: context.operation.name,
+            client_id: context.config.client_side_monitoring_client_id,
+            region: context.config.region,
+            timestamp: DateTime.now.strftime('%Q').to_i,
+          )
+          context.metadata[:client_metrics] = request_metrics
+          start_time = Aws::Util.monotonic_milliseconds
+          final_error_retryable = false
+          final_aws_exception = nil
+          final_aws_exception_message = nil
+          final_sdk_exception = nil
+          final_sdk_exception_message = nil
+          begin
+            @handler.call(context)
+          rescue StandardError => e
+            # Handle SDK Exceptions
+            inspector = Aws::Plugins::RetryErrors::ErrorInspector.new(
+              e,
+              context.http_response.status_code
+            )
+            if inspector.retryable?(context)
+              final_error_retryable = true
+            end
+            if request_metrics.api_call_attempts.empty?
+              attempt = request_metrics.build_call_attempt
+              attempt.sdk_exception = e.class.to_s
+              attempt.sdk_exception_msg = e.message
+              request_metrics.add_call_attempt(attempt)
+            elsif request_metrics.api_call_attempts.last.aws_exception.nil?
+              # Handle exceptions during response handlers
+              attempt = request_metrics.api_call_attempts.last
+              attempt.sdk_exception = e.class.to_s
+              attempt.sdk_exception_msg = e.message
+            elsif !e.class.to_s.match(request_metrics.api_call_attempts.last.aws_exception)
+              # Handle response handling exceptions that happened in addition to
+              # an AWS exception
+              attempt = request_metrics.api_call_attempts.last
+              attempt.sdk_exception = e.class.to_s
+              attempt.sdk_exception_msg = e.message
+            end # Else we don't have an SDK exception and are done.
+            final_attempt = request_metrics.api_call_attempts.last
+            final_aws_exception = final_attempt.aws_exception
+            final_aws_exception_message = final_attempt.aws_exception_msg
+            final_sdk_exception = final_attempt.sdk_exception
+            final_sdk_exception_message = final_attempt.sdk_exception_msg
+            raise e
+          ensure
+            end_time = Aws::Util.monotonic_milliseconds
+            complete_opts = {
+              latency: end_time - start_time,
+              attempt_count: context.retries + 1,
+              user_agent: context.http_request.headers["user-agent"],
+              final_error_retryable: final_error_retryable,
+              final_http_status_code: context.http_response.status_code,
+              final_aws_exception: final_aws_exception,
+              final_aws_exception_message: final_aws_exception_message,
+              final_sdk_exception: final_sdk_exception,
+              final_sdk_exception_message: final_sdk_exception_message
+            }
+            if context.metadata[:redirect_region]
+              complete_opts[:region] = context.metadata[:redirect_region]
+            end
+            request_metrics.api_call.complete(complete_opts)
+            # Report the metrics by passing the complete RequestMetrics object
+            if publisher
+              publisher.publish(request_metrics)
+            end # Else we drop all this on the floor.
+          end
+        end
+
+        private
+        def _calculate_service_id(context)
+          class_name = context.client.class.to_s.match(/(.+)::Client/)[1]
+          class_name.sub!(/^Aws::/, '')
+          _fallback_service_id(class_name)
+        end
+
+        def _fallback_service_id(id)
+          # Need hard-coded exceptions since information needed to
+          # reverse-engineer serviceId is not present in older versions.
+          # This list should not need to grow.
+          exceptions = {
+            "ACMPCA" => "ACM PCA",
+            "APIGateway" => "API Gateway",
+            "AlexaForBusiness" => "Alexa For Business",
+            "ApplicationAutoScaling" => "Application Auto Scaling",
+            "ApplicationDiscoveryService" => "Application Discovery Service",
+            "AutoScaling" => "Auto Scaling",
+            "AutoScalingPlans" => "Auto Scaling Plans",
+            "CloudHSMV2" => "CloudHSM V2",
+            "CloudSearchDomain" => "CloudSearch Domain",
+            "CloudWatchEvents" => "CloudWatch Events",
+            "CloudWatchLogs" => "CloudWatch Logs",
+            "CognitoIdentity" => "Cognito Identity",
+            "CognitoIdentityProvider" => "Cognito Identity Provider",
+            "CognitoSync" => "Cognito Sync",
+            "ConfigService" => "Config Service",
+            "CostExplorer" => "Cost Explorer",
+            "CostandUsageReportService" => "Cost and Usage Report Service",
+            "DataPipeline" => "Data Pipeline",
+            "DatabaseMigrationService" => "Database Migration Service",
+            "DeviceFarm" => "Device Farm",
+            "DirectConnect" => "Direct Connect",
+            "DirectoryService" => "Directory Service",
+            "DynamoDBStreams" => "DynamoDB Streams",
+            "ElasticBeanstalk" => "Elastic Beanstalk",
+            "ElasticLoadBalancing" => "Elastic Load Balancing",
+            "ElasticLoadBalancingV2" => "Elastic Load Balancing v2",
+            "ElasticTranscoder" => "Elastic Transcoder",
+            "ElasticsearchService" => "Elasticsearch Service",
+            "IoTDataPlane" => "IoT Data Plane",
+            "IoTJobsDataPlane" => "IoT Jobs Data Plane",
+            "IoT1ClickDevicesService" => "IoT 1Click Devices Service",
+            "IoT1ClickProjects" => "IoT 1Click Projects",
+            "KinesisAnalytics" => "Kinesis Analytics",
+            "KinesisVideo" => "Kinesis Video",
+            "KinesisVideoArchivedMedia" => "Kinesis Video Archived Media",
+            "KinesisVideoMedia" => "Kinesis Video Media",
+            "LambdaPreview" => "Lambda",
+            "Lex" => "Lex Runtime Service",
+            "LexModelBuildingService" => "Lex Model Building Service",
+            "Lightsail" => "Lightsail",
+            "MQ" => "mq",
+            "MachineLearning" => "Machine Learning",
+            "MarketplaceCommerceAnalytics" => "Marketplace Commerce Analytics",
+            "MarketplaceEntitlementService" => "Marketplace Entitlement Service",
+            "MarketplaceMetering" => "Marketplace Metering",
+            "MediaStoreData" => "MediaStore Data",
+            "MigrationHub" => "Migration Hub",
+            "ResourceGroups" => "Resource Groups",
+            "ResourceGroupsTaggingAPI" => "Resource Groups Tagging API",
+            "Route53" => "Route 53",
+            "Route53Domains" => "Route 53 Domains",
+            "SecretsManager" => "Secrets Manager",
+            "SageMakerRuntime" => "SageMaker Runtime",
+            "ServiceCatalog" => "Service Catalog",
+            "ServiceDiscovery" => "ServiceDiscovery",
+            "Signer" => "signer",
+            "States" => "SFN",
+            "StorageGateway" => "Storage Gateway",
+            "TranscribeService" => "Transcribe Service",
+            "WAFRegional" => "WAF Regional",
+          }
+          if exceptions[id]
+            exceptions[id]
+          else
+            id
+          end
+        end
+      end
+    end
+  end
+end