aws-sdk-core 2.11.175 → 2.11.176

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2704a0fd3ec58947bddca3ee2088e2a76db72a4f
-  data.tar.gz: 29100ed5617f9a7cb3c10f7633dcecc7c6fb1067
+  metadata.gz: 0071e4fe3106f7b8a5536ba25a6460aa2b87dbee
+  data.tar.gz: 7cb903f9379b80c8864c6a5e71ed7f46af7f8138
 SHA512:
-  metadata.gz: c82c4e822c4eef660d3efbd09ee245878d944c6e0a19784a14267a24c066cafcb0a75ea99087f08ac8dbbca7a4d7ca7013e083d6baeb0084bc64b325d574e261
-  data.tar.gz: f8d7f2462e48cf124ec35327841ac6438ffdcdd4389e1a7a723a01772575ae91008b4ff335f3194593b27a4fccd18908a48597f5d1a943db6863ecad4cde31ce
+  metadata.gz: b2c4f2bf73e0cae8cea8d73d69eee330177c1f78b869fe58f4722ebeb667ef5da961c3847f948f84c5db534eddc63fa5602922d0ba61076b56ffba13062289fa
+  data.tar.gz: 93cef4a5cf1992ed98b4174775b9efd0761abfefb212e24d7d284eabe06c6f43a5f9661a9951df438f2796b2712746ffc37d75f1dc7d594a44306452bfd7e515

data/apis/rekognition/2016-06-27/api-2.json

@@ -1511,7 +1511,12 @@
         "mouthUp",
         "mouthDown",
         "leftPupil",
-        "rightPupil"
+        "rightPupil",
+        "upperJawlineLeft",
+        "midJawlineLeft",
+        "chinBottom",
+        "midJawlineRight",
+        "upperJawlineRight"
       ]
     },
     "Landmarks":{

data/lib/aws-sdk-core.rb

@@ -200,6 +200,7 @@ module Aws
   autoload :EagerLoader, 'aws-sdk-core/eager_loader'
   autoload :ECSCredentials, 'aws-sdk-core/ecs_credentials'
   autoload :EndpointProvider, 'aws-sdk-core/endpoint_provider'
+  autoload :EndpointCache, 'aws-sdk-core/endpoint_cache'
   autoload :Errors, 'aws-sdk-core/errors'
   autoload :IniParser, 'aws-sdk-core/ini_parser'
   autoload :InstanceProfileCredentials, 'aws-sdk-core/instance_profile_credentials'
@@ -259,6 +260,8 @@ module Aws
     autoload :HelpfulSocketErrors, 'aws-sdk-core/plugins/helpful_socket_errors'
     autoload :IdempotencyToken, 'aws-sdk-core/plugins/idempotency_token'
     autoload :JsonvalueConverter, 'aws-sdk-core/plugins/jsonvalue_converter'
+    autoload :EndpointDiscovery, 'aws-sdk-core/plugins/endpoint_discovery'
+    autoload :EndpointPattern, 'aws-sdk-core/plugins/endpoint_pattern'
     autoload :Logging, 'aws-sdk-core/plugins/logging'
     autoload :MachineLearningPredictEndpoint, 'aws-sdk-core/plugins/machine_learning_predict_endpoint'
     autoload :ParamConverter, 'aws-sdk-core/plugins/param_converter'
@@ -575,10 +578,10 @@ module Aws
   service_added do |name, svc_module, options|
     if paginators = options[:paginators]
       paginators = Json.load_file(paginators) unless Hash === paginators
-      svc_module::Client.api.operations.each do |_, operation|
-        if rules = paginators['pagination'][operation.name]
-          operation[:pager] = Pager.new(rules)
-        end
+      paginators['pagination'].each do |n, rules|
+        op_name = Seahorse::Util.underscore(n)
+        operation = svc_module::Client.api.operation(op_name)
+        operation[:pager] = Pager.new(rules)
       end
     end
   end

data/lib/aws-sdk-core/api/builder.rb

@@ -58,9 +58,20 @@ module Aws
         api = Seahorse::Model::Api.new
         api.metadata = definition['metadata'] || {}
         api.version = api.metadata['apiVersion']
+        if op = has_endpoint_operation?(definition['operations'])
+          api.endpoint_operation = op
+        end
         api
       end
 
+      def has_endpoint_operation?(ops)
+        return nil if ops.nil?
+        ops.each do |name, op|
+          return underscore(name) if op['endpointoperation']
+        end
+        nil
+      end
+
       def build_shape_map(definition, api, docs)
         shapes = definition['shapes'] || {}
         api.metadata['shapes'] = ShapeMap.new(shapes, docs: docs)
@@ -76,17 +87,29 @@ module Aws
       def build_operation(name, definition, shapes, docs)
         http = definition['http'] || {}
         op = Seahorse::Model::Operation.new
-        op.name = name
+        op.name = definition['name'] || name
         op.http_method = http['method']
         op.http_request_uri = http['requestUri'] || '/'
         op.documentation = docs.operation_docs(name)
         op.deprecated = !!definition['deprecated']
+        op.endpoint_operation = !!definition['endpointoperation']
         op.input = shapes.shape_ref(definition['input'])
         op.output = shapes.shape_ref(definition['output'])
         op['authtype'] = definition['authtype'] unless definition['authtype'].nil?
         (definition['errors'] || []).each do |error|
           op.errors << shapes.shape_ref(error)
         end
+        if definition['endpointdiscovery']
+          op.endpoint_discovery = {}
+          definition['endpointdiscovery'].each do |k, v|
+            op.endpoint_discovery[k] = v
+          end
+        elsif definition['endpoint']
+          op.endpoint_pattern = {}
+          definition['endpoint'].each do |k, v|
+            op.endpoint_pattern[k] = v
+          end
+        end
         op
       end
 

data/lib/aws-sdk-core/api/customizations.rb

@@ -94,7 +94,9 @@ module Aws
       plugins('Amazon CloudSearch Domain',
         add: %w(Aws::Plugins::CSDConditionalSigning
           Aws::Plugins::CSDSwitchToPost),
-        remove: %w(Aws::Plugins::RegionalEndpoint),
+        remove: %w(Aws::Plugins::RegionalEndpoint
+          Aws::Plugins::EndpointPattern
+          Aws::Plugins::EndpointDiscovery),
       )
 
       plugins('Amazon DynamoDB', add: %w(

data/lib/aws-sdk-core/api/shape_map.rb

@@ -54,6 +54,10 @@ module Aws
           location_name = meta.delete('locationName')
           location_name ||= options[:member_name] unless location == 'headers'
           documentation = @docs.shape_ref_docs(shape.name, options[:target])
+          if meta['hostLabel']
+            # used for endpoint pattern
+            meta['hostLabelName'] = options[:member_name]
+          end
 
           ShapeRef.new(
             shape: shape,

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

@@ -17,7 +17,9 @@ module Aws
       'Aws::Plugins::ResponsePaging',
       'Aws::Plugins::StubResponses',
       'Aws::Plugins::IdempotencyToken',
-      'Aws::Plugins::JsonvalueConverter'
+      'Aws::Plugins::JsonvalueConverter',
+      'Aws::Plugins::EndpointDiscovery',
+      'Aws::Plugins::EndpointPattern'
     ]
 
     # @api private

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

@@ -18,6 +18,19 @@ module Aws
         end
         @config.stub_responses = true
       end
+
+      # When a client is stubbed allow the user to access the requests made
+      @api_requests = []
+
+      requests = @api_requests
+      self.handle do |context|
+        requests << {
+          operation_name: context.operation_name,
+          params: context.params,
+          context: context
+        }
+        @handler.call(context)
+      end
     end
 
     # Configures what data / errors should be returned from the named operation
@@ -167,6 +180,27 @@ module Aws
       end
     end
 
+    # Allows you to access all of the requests that the stubbed client has made
+    #
+    # @params [Boolean] exclude_presign Setting to true for filtering out not sent requests from
+    #                 generating presigned urls. Default to false.
+    # @return [Array] Returns an array of the api requests made, each request object contains the
+    #                 :operation_name, :params, and :context of the request. 
+    # @raise [NotImplementedError] Raises `NotImplementedError` when the client is not stubbed
+    def api_requests(options = {})
+      if config.stub_responses
+        if options[:exclude_presign]
+          @api_requests.reject {|req| req[:context][:presigned_url] }
+        else
+          @api_requests
+        end
+      else
+        msg = 'This method is only implemented for stubbed clients, and is '
+        msg << 'available when you enable stubbing in the constructor with `stub_responses: true`'
+        raise NotImplementedError.new(msg)
+      end
+    end
+
     # Generates and returns stubbed response data from the named operation.
     #
     #     s3 = Aws::S3::Client.new

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

@@ -0,0 +1,188 @@
+module Aws
+  # @api private
+  # a LRU cache caching endpoints data
+  class EndpointCache
+
+    # default cache entries limit
+    MAX_ENTRIES = 1000
+
+    # default max threads pool size
+    MAX_THREADS = 10
+
+    def initialize(options = {})
+      @max_entries = options[:max_entries] || MAX_ENTRIES
+      @entries = {} # store endpoints
+      @max_threads = options[:max_threads] || MAX_THREADS
+      @pool = {} # store polling threads
+      @mutex = Mutex.new
+      @require_identifier = nil # whether endpoint operation support identifier
+    end
+
+    # @return [Integer] Max size limit of cache
+    attr_reader :max_entries
+
+    # @return [Integer] Max count of polling threads
+    attr_reader :max_threads
+
+    # return [Hash] Polling threads pool
+    attr_reader :pool
+
+    # @param [String] key
+    # @return [Endpoint]
+    def [](key)
+      @mutex.synchronize do
+        # fetching an existing endpoint delete it and then append it
+        endpoint = @entries[key]
+        if endpoint
+          @entries.delete(key)
+          @entries[key] = endpoint
+        end
+        endpoint
+      end
+    end
+
+    # @param [String] key
+    # @param [Hash] value
+    def []=(key, value)
+      @mutex.synchronize do
+        # delete the least recent used endpoint when cache is full
+        unless @entries.size < @max_entries
+          old_key, _ = @entries.shift
+          self.delete_polling_thread(old_key)
+        end
+        # delete old value if exists
+        @entries.delete(key)
+        @entries[key] = Endpoint.new(value.to_hash)
+      end
+    end
+
+    # checking whether an unexpired endpoint key exists in cache
+    # @param [String] key
+    # @return [Boolean]
+    def key?(key)
+      if @entries.key?(key) && (@entries[key].nil? || @entries[key].expired?)
+        self.delete(key)
+      end
+      @entries.key?(key)
+    end
+
+    # checking whether an polling thread exist for the key
+    # @param [String] key
+    # @return [Boolean]
+    def threads_key?(key)
+      @pool.key?(key)
+    end
+
+    # remove entry only
+    # @param [String] key
+    def delete(key)
+      @mutex.synchronize do
+        @entries.delete(key)
+      end
+    end
+
+    # kill the old polling thread and remove it from pool
+    # @param [String] key
+    def delete_polling_thread(key)
+      Thread.kill(@pool[key]) if self.threads_key?(key)
+      @pool.delete(key)
+    end
+
+    # update cache with requests (using service endpoint operation)
+    # to fetch endpoint list (with identifiers when available)
+    # @param [String] key
+    # @param [RequestContext] ctx
+    def update(key, ctx)
+      resp = _request_endpoint(ctx)
+      if resp && resp.endpoints
+        resp.endpoints.each { |e| self[key] = e }
+      end
+    end
+
+    # extract the key to be used in the cache from request context
+    # @param [RequestContext] ctx
+    # @return [String]
+    def extract_key(ctx)
+      parts = []
+      # fetching from cred provider directly gives warnings
+      parts << ctx.config.credentials.credentials.access_key_id
+      if _endpoint_operation_identifier(ctx)
+        parts << ctx.operation_name
+        ctx.operation.input.shape.members.inject(parts) do |p, (name, ref)|
+          p << ctx.params[name] if ref["endpointdiscoveryid"]
+          p
+        end
+      end
+      parts.join('_')
+    end
+
+    # update polling threads pool
+    # param [String] key
+    # param [Thread] thread
+    def update_polling_pool(key, thread)
+      unless @pool.size < @max_threads
+        _, thread = @pool.shift
+        Thread.kill(thread)
+      end
+      @pool[key] = thread
+    end
+
+    # kill all polling threads
+    def stop_polling!
+      @pool.each { |_, t| Thread.kill(t) }
+      @pool = {}
+    end
+
+    private
+
+    def _request_endpoint(ctx)
+      params = {}
+      if _endpoint_operation_identifier(ctx)
+        # build identifier params when available
+        params[:operation] = ctx.operation.name
+        ctx.operation.input.shape.members.inject(params) do |p, (name, ref)|
+          if ref["endpointdiscoveryid"]
+            p[:identifiers] ||= {}
+            p[:identifiers][ref.location_name] = ctx.params[name]
+          end
+          p
+        end
+      end
+
+      begin
+        endpoint_operation_name = ctx.config.api.endpoint_operation
+        ctx.client.send(endpoint_operation_name, params)
+      rescue Aws::Errors::ServiceError
+        nil 
+      end
+    end
+
+    def _endpoint_operation_identifier(ctx)
+      return @require_identifier unless @require_identifier.nil?
+      operation_name = ctx.config.api.endpoint_operation
+      operation = ctx.config.api.operation(operation_name)
+      @require_identifier = operation.input.shape.members.any?
+    end
+
+    class Endpoint
+    
+      # default endpoint cache time, 1 minute
+      CACHE_PERIOD = 1
+
+      def initialize(options)
+        @address = options.fetch(:address)
+        @cache_period = options[:cache_period_in_minutes] || CACHE_PERIOD
+        @created_time = Time.now
+      end
+
+      # [String] valid URI address (with path) 
+      attr_reader :address
+
+      def expired?
+        Time.now - @created_time > @cache_period * 60
+      end
+
+    end
+
+  end
+end

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

@@ -53,6 +53,30 @@ module Aws
     # Raised when a {Service} is constructed and region is not specified.
     class MissingRegionError < ArgumentError; end
 
+    # Rasied when endpoint discovery failed for operations
+    # that requires endpoints from endpoint discovery
+    class EndpointDiscoveryError < RuntimeError
+      def initialize(*args)
+        msg = 'Endpoint discovery failed for the operation or discovered endpoint is not working, '\
+          'request will keep failing until endpoint discovery succeeds or :endpoint option is provided.'
+        super(msg)
+      end
+    end
+
+    # raised when hostLabel member is not provided
+    # at operation input when endpoint trait is available
+    # with 'hostPrefix' requirement
+    class MissingEndpointHostLabelValue < RuntimeError
+
+      def initialize(name)
+        msg = "Missing required parameter #{name} to construct"\
+          " endpoint host prefix. You can disable host prefix by"\
+          " setting :disable_host_prefix_injection to `true`."
+        super(msg)
+      end
+
+    end
+
     # Raised when attempting to connect to an endpoint and a `SocketError`
     # is received from the HTTP client. This error is typically the result
     # of configuring an invalid `:region`.

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

@@ -0,0 +1,167 @@
+module Aws
+  module Plugins
+
+    # Enables Endpoint Discovery per service when supported
+    #
+    # @seahorse.client.option [Boolean] :endpoint_discovery When
+    #     set to `true`, endpoint discovery will be enabled for
+    #     operations when available. Defaults to `false`.
+    #
+    # @seahorse.client.option [Integer] :endpoint_cache_max_entries
+    #   Used for the maximum size limit of the LRU cache storing endpoints data
+    #   for endpoint discovery enabled operations. Defaults to 1000.
+    #
+    # @seahorse.client.option [Integer] :endpoint_cache_max_threads
+    #   Used for the maximum threads in use for polling endpoints to be cached,
+    #   defaults to 10.
+    #
+    # @seahorse.client.option [Integer] :endpoint_cache_poll_interval
+    #   When :endpoint_discovery and :active_endpoint_cache is enabled,
+    #   Use this option to config the time interval in seconds for making
+    #   requests fetching endpoints information. Defaults to 60 sec.
+    #
+    # @seahorse.client.option [Boolean] :active_endpoint_cache
+    #   When set to `true`, a thread polling for endpoints will be running in
+    #   the background every 60 secs (default). Defaults to `false`.
+    class EndpointDiscovery < Seahorse::Client::Plugin
+
+      option(:endpoint_discovery, false) do |cfg|
+        resolve_endpoint_discovery(cfg)
+      end
+
+      option(:endpoint_cache_max_entries, 1000)
+
+      option(:endpoint_cache_max_threads, 10)
+
+      option(:endpoint_cache_poll_interval, 60)
+
+      option(:endpoint_cache) do |cfg|
+        Aws::EndpointCache.new(
+          max_entries: cfg.endpoint_cache_max_entries,
+          max_threads: cfg.endpoint_cache_max_threads
+        )
+      end
+
+      option(:active_endpoint_cache, false)
+
+      def add_handlers(handlers, config)
+        handlers.add(Handler, priority: 90) if config.regional_endpoint
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          if context.operation.endpoint_operation
+            context.http_request.headers['x-amz-api-version'] = context.config.api.version
+            _apply_endpoint_discovery_user_agent(context)
+          elsif discovery_cfg = context.operation.endpoint_discovery
+            endpoint = _discover_endpoint(
+              context,
+              str_2_bool(discovery_cfg["required"])
+            )
+            context.http_request.endpoint = _valid_uri(endpoint.address) if endpoint
+            if endpoint || context.config.endpoint_discovery
+              _apply_endpoint_discovery_user_agent(context)
+            end
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def _valid_uri(address)
+          # returned address can be missing scheme
+          if address.start_with?('http')
+            URI.parse(address)
+          else
+            URI.parse("https://" + address)
+          end
+        end
+
+        def _apply_endpoint_discovery_user_agent(ctx)
+          if ctx.config.user_agent_suffix.nil?
+            ctx.config.user_agent_suffix = "endpoint-discovery"
+          elsif !ctx.config.user_agent_suffix.include? "endpoint-discovery"
+            ctx.config.user_agent_suffix += "endpoint-discovery"
+          end
+        end
+
+        def _discover_endpoint(ctx, required)
+          cache = ctx.config.endpoint_cache 
+          key = cache.extract_key(ctx)
+
+          if required
+            # required for the operation
+            unless cache.key?(key)
+              cache.update(key, ctx)
+            end
+            endpoint = cache[key]
+            # hard fail if endpoint is not discovered
+            raise Aws::Errors::EndpointDiscoveryError.new unless endpoint
+            endpoint
+          elsif ctx.config.endpoint_discovery
+            # not required for the operation
+            # but enabled
+            if cache.key?(key)
+              cache[key]
+            elsif ctx.config.active_endpoint_cache
+              # enabled active cache pull
+              interval = ctx.config.endpoint_cache_poll_interval
+              if key.include?('_')
+                # identifier related, kill the previous polling thread by key
+                # because endpoint req params might be changed
+                cache.delete_polling_thread(key)
+              end
+
+              # start a thread for polling endpoints when non-exist
+              unless cache.threads_key?(key)
+                thread = Thread.new do
+                  while !cache.key?(key) do
+                    cache.update(key, ctx)
+                    sleep(interval)
+                  end
+                end
+                cache.update_polling_pool(key, thread)
+              end
+
+              cache[key]
+            else
+              # disabled active cache pull
+              # attempt, buit fail soft
+              cache.update(key, ctx)
+              cache[key]
+            end
+          end
+        end
+
+        def str_2_bool(str)
+          case str.to_s
+          when "true" then true
+          when "false" then false
+          else
+            nil
+          end
+        end
+
+      end
+
+      private
+
+      def self.resolve_endpoint_discovery(cfg)
+        env = ENV['AWS_ENABLE_ENDPOINT_DISCOVERY']
+        shared_cfg = Aws.shared_config.endpoint_discovery(profile: cfg.profile)
+        self.str_2_bool(env) || self.str_2_bool(shared_cfg)
+      end
+
+      def self.str_2_bool(str)
+        case str.to_s
+        when "true" then true
+        when "false" then false
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Aws
+  module Plugins
+
+    # Disable host prefix per operation when available
+    #
+    # @seahorse.client.option [Boolean] :disable_host_prefix_injection
+    #   Set to true to disable SDK automatically adding host prefix
+    #   to default service endpoint when available.
+    #
+    class EndpointPattern < Seahorse::Client::Plugin
+
+      option(:disable_host_prefix_injection, false)
+
+      def add_handlers(handlers, config)
+        if config.regional_endpoint && !config.disable_host_prefix_injection
+          handlers.add(Handler, priority: 90)
+        end
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          endpoint_trait = context.operation.endpoint_pattern
+          if endpoint_trait && !endpoint_trait.empty?
+            _apply_endpoint_trait(context, endpoint_trait)
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def _apply_endpoint_trait(context, trait)
+          # currently only support host pattern
+          ori_host = context.http_request.endpoint.host
+          if pattern = trait['hostPrefix']
+            host_prefix = pattern.gsub(/\{.+?\}/) do |label|
+              label = label.delete("{}")
+              _replace_label_value(
+                ori_host, label, context.operation.input, context.params)
+            end
+            context.http_request.endpoint.host = host_prefix + context.http_request.endpoint.host
+          end
+        end
+
+        def _replace_label_value(ori, label, input_ref, params)
+          name = nil
+          input_ref.shape.members.each do |m_name, ref|
+            if ref['hostLabel'] && ref['hostLabelName'] == label
+              name = m_name
+            end
+          end
+          if name.nil? || params[name].nil?
+            raise Errors::MissingEndpointHostLabelValue.new(name)
+          end
+          params[name]
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -20,6 +20,8 @@ module Aws
         resolve_region(cfg)
       end
 
+      option(:regional_endpoint, false)
+
       option(:endpoint) do |cfg|
         endpoint_prefix = cfg.api.metadata['endpointPrefix']
         if cfg.region && endpoint_prefix

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

@@ -71,6 +71,25 @@ module Aws
           (500..599).include?(@http_status_code)
         end
 
+        def endpoint_discovery?(context)
+          return false unless context.operation.endpoint_discovery
+
+          if @http_status_code == 421 ||
+            extract_name(@error) == 'InvalidEndpointException'
+            @error = Errors::EndpointDiscoveryError.new
+          end
+
+          # When endpoint discovery error occurs
+          # evict the endpoint from cache
+          if @error.is_a?(Errors::EndpointDiscoveryError)
+            key = context.config.endpoint_cache.extract_key(context)
+            context.config.endpoint_cache.delete(key)
+            true
+          else
+            false
+          end
+        end
+
         private
 
         def extract_name(error)
@@ -135,7 +154,8 @@ module Aws
           error.throttling_error? or
           error.checksum? or
           error.networking? or
-          error.server?
+          error.server? or
+          error.endpoint_discovery?(context)
         end
 
         def refreshable_credentials?(context)

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

@@ -7,7 +7,9 @@ module Aws
 
       class Handler < Seahorse::Client::Handler
         def call(context)
-          move_account_id_to_subdomain(context)
+          if context.operation.endpoint_pattern.nil?
+            move_account_id_to_subdomain(context)
+          end
           @handler.call(context)
         end
 

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

@@ -128,6 +128,13 @@ module Aws
       end
     end
 
+    def endpoint_discovery(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled && @parsed_config
+        @parsed_config.fetch(p, {})["endpoint_discovery_enabled"]
+      end
+    end
+
     private
     def credentials_present?
       (@parsed_credentials && !@parsed_credentials.empty?) ||

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

@@ -1,3 +1,3 @@
 module Aws
-  VERSION = '2.11.175'
+  VERSION = '2.11.176'
 end

data/lib/seahorse/client/configuration.rb

@@ -197,7 +197,13 @@ module Seahorse
 
         def value_at(opt_name)
           value = @struct[opt_name]
-          value.is_a?(Defaults) ? resolve_defaults(opt_name, value) : value
+          if value.is_a?(Defaults)
+            # this config value is used by endpoint discovery etc
+            @struct[:regional_endpoint] = true if opt_name == :endpoint
+            resolve_defaults(opt_name, value)
+          else
+            value
+          end
         end
 
         def resolve_defaults(opt_name, defaults)

data/lib/seahorse/model/api.rb

@@ -5,6 +5,7 @@ module Seahorse
       def initialize
         @metadata = {}
         @operations = {}
+        @endpoint_operation = nil
       end
 
       # @return [String, nil]
@@ -13,6 +14,9 @@ module Seahorse
       # @return [Hash]
       attr_accessor :metadata
 
+      # @return [Symbol|nil]
+      attr_accessor :endpoint_operation
+
       def operations(&block)
         if block_given?
           @operations.each(&block)

data/lib/seahorse/model/operation.rb

@@ -22,9 +22,18 @@ module Seahorse
       # @return [Boolean]
       attr_accessor :deprecated
 
+      # @return [Boolean]
+      attr_accessor :endpoint_operation
+
+      # @return [Hash]
+      attr_accessor :endpoint_discovery
+
       # @return [String, nil]
       attr_accessor :documentation
 
+      # @return [Hash, nil]
+      attr_accessor :endpoint_pattern
+
       # @return [ShapeRef, nil]
       attr_accessor :input
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-core
 version: !ruby/object:Gem::Version
-  version: 2.11.175
+  version: 2.11.176
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-20 00:00:00.000000000 Z
+date: 2018-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jmespath
@@ -765,6 +765,7 @@ files:
 - lib/aws-sdk-core/elastictranscoder.rb
 - lib/aws-sdk-core/empty_structure.rb
 - lib/aws-sdk-core/emr.rb
+- lib/aws-sdk-core/endpoint_cache.rb
 - lib/aws-sdk-core/endpoint_provider.rb
 - lib/aws-sdk-core/errors.rb
 - lib/aws-sdk-core/firehose.rb
@@ -848,6 +849,8 @@ files:
 - lib/aws-sdk-core/plugins/dynamodb_simple_attributes.rb
 - lib/aws-sdk-core/plugins/ec2_copy_encrypted_snapshot.rb
 - lib/aws-sdk-core/plugins/ec2_region_validation.rb
+- lib/aws-sdk-core/plugins/endpoint_discovery.rb
+- lib/aws-sdk-core/plugins/endpoint_pattern.rb
 - lib/aws-sdk-core/plugins/glacier_account_id.rb
 - lib/aws-sdk-core/plugins/glacier_api_version.rb
 - lib/aws-sdk-core/plugins/glacier_checksums.rb