aws-sdk-core 2.11.549

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

@@ -0,0 +1,7 @@
+Aws.add_service(:ElasticBeanstalk, {
+  api: "#{Aws::API_DIR}/elasticbeanstalk/2010-12-01/api-2.json",
+  docs: "#{Aws::API_DIR}/elasticbeanstalk/2010-12-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/elasticbeanstalk/2010-12-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/elasticbeanstalk/2010-12-01/paginators-1.json",
+  waiters: "#{Aws::API_DIR}/elasticbeanstalk/2010-12-01/waiters-2.json",
+})

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

@@ -0,0 +1,6 @@
+Aws.add_service(:ElasticInference, {
+  api: "#{Aws::API_DIR}/elastic-inference/2017-07-25/api-2.json",
+  docs: "#{Aws::API_DIR}/elastic-inference/2017-07-25/docs-2.json",
+  examples: "#{Aws::API_DIR}/elastic-inference/2017-07-25/examples-1.json",
+  paginators: "#{Aws::API_DIR}/elastic-inference/2017-07-25/paginators-1.json",
+})

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

@@ -0,0 +1,7 @@
+Aws.add_service(:ElasticLoadBalancing, {
+  api: "#{Aws::API_DIR}/elasticloadbalancing/2012-06-01/api-2.json",
+  docs: "#{Aws::API_DIR}/elasticloadbalancing/2012-06-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/elasticloadbalancing/2012-06-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/elasticloadbalancing/2012-06-01/paginators-1.json",
+  waiters: "#{Aws::API_DIR}/elasticloadbalancing/2012-06-01/waiters-2.json",
+})

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

@@ -0,0 +1,7 @@
+Aws.add_service(:ElasticLoadBalancingV2, {
+  api: "#{Aws::API_DIR}/elasticloadbalancingv2/2015-12-01/api-2.json",
+  docs: "#{Aws::API_DIR}/elasticloadbalancingv2/2015-12-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/elasticloadbalancingv2/2015-12-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/elasticloadbalancingv2/2015-12-01/paginators-1.json",
+  waiters: "#{Aws::API_DIR}/elasticloadbalancingv2/2015-12-01/waiters-2.json",
+})

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

@@ -0,0 +1,6 @@
+Aws.add_service(:ElasticsearchService, {
+  api: "#{Aws::API_DIR}/es/2015-01-01/api-2.json",
+  docs: "#{Aws::API_DIR}/es/2015-01-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/es/2015-01-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/es/2015-01-01/paginators-1.json",
+})

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

@@ -0,0 +1,7 @@
+Aws.add_service(:ElasticTranscoder, {
+  api: "#{Aws::API_DIR}/elastictranscoder/2012-09-25/api-2.json",
+  docs: "#{Aws::API_DIR}/elastictranscoder/2012-09-25/docs-2.json",
+  examples: "#{Aws::API_DIR}/elastictranscoder/2012-09-25/examples-1.json",
+  paginators: "#{Aws::API_DIR}/elastictranscoder/2012-09-25/paginators-1.json",
+  waiters: "#{Aws::API_DIR}/elastictranscoder/2012-09-25/waiters-2.json",
+})

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

@@ -0,0 +1,3 @@
+module Aws
+  EmptyStructure = Class.new(Structure.new('AwsEmptyStructure'))
+end

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

@@ -0,0 +1,7 @@
+Aws.add_service(:EMR, {
+  api: "#{Aws::API_DIR}/elasticmapreduce/2009-03-31/api-2.json",
+  docs: "#{Aws::API_DIR}/elasticmapreduce/2009-03-31/docs-2.json",
+  examples: "#{Aws::API_DIR}/elasticmapreduce/2009-03-31/examples-1.json",
+  paginators: "#{Aws::API_DIR}/elasticmapreduce/2009-03-31/paginators-1.json",
+  waiters: "#{Aws::API_DIR}/elasticmapreduce/2009-03-31/waiters-2.json",
+})

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/endpoint_provider.rb

@@ -0,0 +1,131 @@
+module Aws
+  # @api private
+  class EndpointProvider
+
+    # when sts_regional_endpoint set to `legacy`
+    # endpoint pattern stays global for
+    # following regions
+    STS_LEGACY_REGIONS = %w(
+      ap-northeast-1
+      ap-south-1
+      ap-southeast-1
+      ap-southeast-2
+      aws-global
+      ca-central-1
+      eu-central-1
+      eu-north-1
+      eu-west-1
+      eu-west-2
+      eu-west-3
+      sa-east-1
+      us-east-1
+      us-east-2
+      us-west-1
+      us-west-2
+    )
+
+    def initialize(rules)
+      @rules = rules
+    end
+
+    def resolve(region, service, sts_regional_endpoints)
+      "https://" + endpoint_for(region, service, sts_regional_endpoints)
+    end
+
+    def signing_region(region, service)
+      get_partition(region).
+        fetch("services", {}).
+        fetch(service, {}).
+        fetch("endpoints", {}).
+        fetch(region, {}).
+        fetch("credentialScope", {}).
+        fetch("region", region)
+    end
+
+    def dns_suffix_for(region)
+      partition = get_partition(region)
+      partition['dnsSuffix']
+    end
+
+    private
+
+    def endpoint_for(region, service, sts_regional_endpoints = 'regional')
+      partition = get_partition(region)
+      endpoint = default_endpoint(partition, service, region)
+      service_cfg = partition.fetch("services", {}).fetch(service, {})
+
+      # Check for service-level default endpoint.
+      endpoint = service_cfg.fetch("defaults", {}).fetch("hostname", endpoint)
+
+      # Check for sts legacy behavior
+      sts_legacy = service == 'sts' &&
+        sts_regional_endpoints == 'legacy' &&
+        STS_LEGACY_REGIONS.include?(region)
+
+      # Check for global endpoint.
+      if sts_legacy || service_cfg["isRegionalized"] == false
+        region = service_cfg.fetch("partitionEndpoint", region)
+      end
+
+      # Check for service/region level endpoint.
+      endpoint = service_cfg.fetch("endpoints", {}).
+        fetch(region, {}).fetch("hostname", endpoint)
+
+      endpoint
+    end
+
+    def default_endpoint(partition, service, region)
+      hostname_template = partition["defaults"]["hostname"]
+      hostname_template.
+        sub('{region}', region).
+        sub('{service}', service).
+        sub('{dnsSuffix}', partition["dnsSuffix"])
+    end
+
+    def get_partition(region)
+      partition_containing_region(region) ||
+      partition_matching_region(region) ||
+      default_partition
+    end
+
+    def partition_containing_region(region)
+      @rules['partitions'].find do |p|
+        p['regions'].key?(region)
+      end
+    end
+
+    def partition_matching_region(region)
+      @rules['partitions'].find do |p|
+        region.match(p["regionRegex"]) ||
+          p['services'].values.find { |svc| svc['endpoints'].key?(region) if svc.key? 'endpoints'}
+      end
+    end
+
+    def default_partition
+      @rules['partitions'].find { |p| p["partition"] == "aws" } ||
+      @rules['partitions'].first
+    end
+
+    class << self
+
+      def resolve(region, service, sts_regional_endpoints = 'regional')
+        default_provider.resolve(region, service, sts_regional_endpoints)
+      end
+
+      def signing_region(region, service)
+        default_provider.signing_region(region, service)
+      end
+
+      def dns_suffix_for(region)
+        default_provider.dns_suffix_for(region)
+      end
+
+      private
+
+      def default_provider
+        @default_provider ||= EndpointProvider.new(Partitions.defaults)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+require 'thread'
+
+module Aws
+
+  # Each Service module has its own Errors module, e.g. {S3::Errors}.
+  module Errors
+
+    # The base class for all errors returned by an Amazon Web Service.
+    # All ~400 level client errors and ~500 level server errors are raised
+    # as service errors.  This indicates it was an error returned from the
+    # service and not one generated by the client.
+    class ServiceError < RuntimeError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      def initialize(context, message)
+        @code = self.class.code
+        @context = context
+        super(message)
+      end
+
+      # @return [String]
+      attr_reader :code
+
+      # @return [Seahorse::Client::RequestContext] The context of the request
+      #   that triggered the remote service to return this error.
+      attr_reader :context
+
+      class << self
+
+        # @return [String]
+        attr_accessor :code
+
+      end
+    end
+
+    # Raised when InstanceProfileCredentialsProvider or
+    # EcsCredentialsProvider fails to parse the metadata response after retries
+    class MetadataParserError < RuntimeError
+      def initialize(*args)
+        msg = "Failed to parse metadata service response."
+        super(msg)
+      end
+    end
+
+    # Various plugins perform client-side checksums of responses.
+    # This error indicates a checksum failed.
+    class ChecksumError < RuntimeError; end
+
+    # Raised when a {Service} is constructed and the specified shared
+    # credentials profile does not exist.
+    class NoSuchProfileError < RuntimeError; end
+
+    # Raised when a {Service} is constructed, where Assume Role credentials are
+    # expected, and there is no source profile specified.
+    class NoSourceProfileError < RuntimeError; end
+
+    # Raised when a {Service} is constructed and credentials are not
+    # set, or the set credentials are empty.
+    class MissingCredentialsError < RuntimeError; end
+
+    # 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`.
+    class NoSuchEndpointError < RuntimeError
+
+      def initialize(options = {})
+        @context = options[:context]
+        @endpoint = @context.http_request.endpoint
+        @original_error = options[:original_error]
+        super(<<-MSG)
+Encountered a `SocketError` while attempting to connect to:
+
+  #{endpoint.to_s}
+
+This is typically the result of an invalid `:region` option or a
+poorly formatted `:endpoint` option.
+
+* Avoid configuring the `:endpoint` option directly. Endpoints are constructed
+  from the `:region`. The `:endpoint` option is reserved for connecting to
+  non-standard test endpoints.
+
+* Not every service is available in every region.
+
+* Never suffix region names with availability zones.
+  Use "us-east-1", not "us-east-1a"
+
+Known AWS regions include (not specific to this service):
+
+#{possible_regions}
+        MSG
+      end
+
+      attr_reader :context
+
+      attr_reader :endpoint
+
+      attr_reader :original_error
+
+      private
+
+      def possible_regions
+        Aws.partitions.inject([]) do |region_names, partition|
+          partition.regions.each do |region|
+            region_names << region.name
+          end
+          region_names
+        end.join("\n")
+      end
+
+    end
+
+    # This module is mixed into another module, providing dynamic
+    # error classes.  Error classes all inherit from {ServiceError}.
+    #
+    #     # creates and returns the class
+    #     Aws::S3::Errors::MyNewErrorClass
+    #
+    # Since the complete list of possible AWS errors returned by services
+    # is not known, this allows us to create them as needed.  This also
+    # allows users to rescue errors by class without them being concrete
+    # classes beforehand.
+    #
+    # @api private
+    module DynamicErrors
+
+      def self.extended(submodule)
+        submodule.instance_variable_set("@const_set_mutex", Mutex.new)
+        submodule.const_set(:ServiceError, Class.new(ServiceError))
+      end
+
+      def const_missing(constant)
+        set_error_constant(constant)
+      end
+
+      # Given the name of a service and an error code, this method
+      # returns an error class (that extends {ServiceError}.
+      #
+      #     Aws::S3::Errors.error_class('NoSuchBucket').new
+      #     #=> #<Aws::S3::Errors::NoSuchBucket>
+      #
+      # @api private
+      def error_class(error_code)
+        constant = error_class_constant(error_code)
+        if error_const_set?(constant)
+          const_get(constant)
+        else
+          set_error_constant(constant)
+        end
+      end
+
+      private
+
+      # Convert an error code to an error class name/constant.
+      # This requires filtering non-safe characters from the constant
+      # name and ensuring it begins with an uppercase letter.
+      # @param [String] error_code
+      # @return [Symbol] Returns a symbolized constant name for the given
+      #   `error_code`.
+      def error_class_constant(error_code)
+        constant = error_code.to_s
+        constant = constant.gsub(/https?:.*$/, '')
+        constant = constant.gsub(/[^a-zA-Z0-9]/, '')
+        constant = 'Error' + constant unless constant.match(/^[a-z]/i)
+        constant = constant[0].upcase + constant[1..-1]
+        constant.to_sym
+      end
+
+      def set_error_constant(constant)
+        @const_set_mutex.synchronize do
+          # Ensure the const was not defined while blocked by the mutex
+          if error_const_set?(constant)
+            const_get(constant)
+          else
+            error_class = Class.new(const_get(:ServiceError))
+            error_class.code = constant.to_s
+            const_set(constant, error_class)
+          end
+        end
+      end
+
+      def error_const_set?(constant)
+        # Purposefully not using #const_defined? as that method returns true
+        # for constants not defined directly in the current module.
+        constants.include?(constant.to_sym)
+      end
+
+    end
+  end
+end