aws-sdk-core 2.4.0 → 3.53.0

data/lib/aws-sdk-core/partitions/region.rb

@@ -1,78 +0,0 @@
-require 'set'
-
-module Aws
-  module Partitions
-    class Region
-
-      # @option options [required, String] :name
-      # @option options [required, String] :description
-      # @option options [required, String] :partition_name
-      # @option options [required, Set<String>] :services
-      # @api private
-      def initialize(options = {})
-        @name = options[:name]
-        @description = options[:description]
-        @partition_name = options[:partition_name]
-        @services = options[:services]
-      end
-
-      # @return [String] The name of this region, e.g. "us-east-1".
-      attr_reader :name
-
-      # @return [String] A short description of this region.
-      attr_reader :description
-
-      # @return [String] The partition this region exists in, e.g. "aws",
-      #   "aws-cn", "aws-us-gov".
-      attr_reader :partition_name
-
-      # @return [Set<String>] The list of services available in this region.
-      #   Service names are the module names as used by the AWS SDK
-      #   for Ruby.
-      attr_reader :services
-
-      class << self
-
-        # @api private
-        def build(region_name, region, partition)
-          Region.new(
-            name: region_name,
-            description: region['description'],
-            partition_name: partition['partition'],
-            services: region_services(region_name, partition)
-          )
-        end
-
-        private
-
-        def region_services(region_name, partition)
-          Partitions.service_ids.inject(Set.new) do |services, (svc_name, svc_id)|
-            if svc = partition['services'][svc_id]
-              services << svc_name if service_in_region?(svc, region_name)
-            else
-              #raise "missing endpoints for #{svc_name} / #{svc_id}"
-            end
-            services
-          end
-        end
-
-        def service_in_region?(svc, region_name)
-          svc_endpoints_contains_region?(svc, region_name) ||
-          svc_partition_endpoint_matches_region?(svc, region_name)
-        end
-
-        def svc_endpoints_contains_region?(svc, region_name)
-          svc['endpoints'].key?(region_name)
-        end
-
-        def svc_partition_endpoint_matches_region?(svc, region_name)
-          if pe = svc['partitionEndpoint']
-            region = svc['endpoints'][pe].fetch('credentialScope', {})['region']
-            region == region_name
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/aws-sdk-core/partitions/service.rb

@@ -1,84 +0,0 @@
-require 'set'
-
-module Aws
-  module Partitions
-    class Service
-
-      # @option options [required, String] :name
-      # @option options [required, String] :partition_name
-      # @option options [required, Set<String>] :region_name
-      # @option options [required, Boolean] :regionalized
-      # @option options [String] :partition_region
-      # @api private
-      def initialize(options = {})
-        @name = options[:name]
-        @partition_name = options[:partition_name]
-        @regions = options[:regions]
-        @regionalized = options[:regionalized]
-        @partition_region = options[:partition_region]
-        @regions << @partition_region if !@regionalized
-      end
-
-      # @return [String] The name of this service. The name is the module
-      #   name as used by the AWS SDK for Ruby.
-      attr_reader :name
-
-      # @return [String] The partition name, e.g "aws", "aws-cn", "aws-us-gov".
-      attr_reader :partition_name
-
-      # @return [Set<String>] The regions this service is available in.
-      #   Regions are scoped to the partition.
-      attr_reader :regions
-
-      # @return [String,nil] The global patition endpoint for this service.
-      #   May be `nil`.
-      attr_reader :partition_region
-
-      # Returns `false` if the service operates with a single global
-      # endpoint for the current partition, returns `true` if the service
-      # is available in mutliple regions.
-      #
-      # Some services have both a partition endpoint and regional endpoints.
-      #
-      # @return [Boolean]
-      def regionalized?
-        @regionalized
-      end
-
-      class << self
-
-        # @api private
-        def build(service_name, service, partition)
-          Service.new(
-            name: service_name,
-            partition_name: partition['partition'],
-            regions: regions(service, partition),
-            regionalized: service['isRegionalized'] != false,
-            partition_region: partition_region(service)
-          )
-        end
-
-        private
-
-        def regions(service, partition)
-          names = Set.new(partition['regions'].keys & service['endpoints'].keys)
-          names - ["#{partition['partition']}-global"]
-        end
-
-        def partition_region(service)
-          if service['partitionEndpoint']
-            endpoint = service['endpoints'][service['partitionEndpoint']]
-            if endpoint['credentialScope']
-              endpoint['credentialScope']['region']
-            elsif service['defaults'] && service['defaults']['credentialScope']
-              service['defaults']['credentialScope']['region']
-            else
-              service['partitionEndpoint']
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Aws
-  module Plugins
-    # @api private
-    class APIGatewayHeader < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          context.http_request.headers['Accept'] = 'application/json'
-          @handler.call(context)
-        end
-
-      end
-
-      handler(Handler)
-
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-module Aws
-  module Plugins
-
-    # Makes it possible to conditional sign {Aws::CloudSearchDomain::Client}
-    # requests. When credentials are configured, requests are signed.
-    # When they are omitted, the request is sent anonymously.
-    #
-    # @seahorse.client.option [String] :sigv4_region Only needed when sending
-    #   authenticated/signed requests to a Cloud Search domain and the
-    #   endpoint does not contain the region name.
-    #
-    class CSDConditionalSigning < Seahorse::Client::Plugin
-
-      # Adding region as an option to avoid an issue when `Aws.config[:region]`
-      # is populated and the global configuration plugin merges options onto
-      # this client.
-      option(:region)
-
-      option(:sigv4_region) do |cfg|
-        # extract the region name from the cloud search domain endpoint
-        if cfg.endpoint
-          cfg.endpoint.to_s.split('.')[1]
-        else
-          raise ArgumentError, 'missing required option :endpoint'
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-module Aws
-  module Plugins
-
-    # @seahorse.client.option [Boolean] :compute_checksums (true)
-    #   When `true`, a CRC32 checksum is computed of every HTTP
-    #   response body and compared against the `X-Amz-Crc32` header.
-    #   If the checksums do not match, the request is re-sent.
-    #   Failures can be retried up to `:retry_limit` times.
-    class DynamoDBCRC32Validation < Seahorse::Client::Plugin
-
-      option(:compute_checksums, true)
-
-      def add_handlers(handlers, config)
-        if config.compute_checksums
-          handlers.add(Handler, step: :sign)
-        end
-      end
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          # disable response gzipping - Net::HTTP unzips these responses
-          # before we can see the body, making it impossible to verify
-          # the CRC32 checksum against the compressed body stream
-          context.http_request.headers['accept-encoding'] = ''
-
-          @handler.call(context).on_success do |response|
-            response.error = validate(context)
-          end
-        end
-
-        private
-
-        def validate(context)
-          unless crc32_is_valid?(context.http_response)
-            msg = "Response failed CRC32 check."
-            return Aws::DynamoDB::Errors::CRC32CheckFailed.new(context, msg)
-          end
-        end
-
-        def crc32_is_valid?(response)
-          if crc_checksum = response.headers['x-amz-crc32']
-            crc_checksum.to_i == Zlib.crc32(response.body_contents)
-          else
-            true
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-module Aws
-  module Plugins
-
-    # @seahorse.client.option [Integer] :retry_limit (10)
-    #   The maximum number of times to retry failed requests.  Only
-    #   ~ 500 level server errors and certain ~ 400 level client errors
-    #   are retried.  Generally, these are throttling errors, data
-    #   checksum errors, networking errors, timeout errors and auth
-    #   errors from expired credentials.
-    class DynamoDBExtendedRetries < Seahorse::Client::Plugin
-
-      option(:retry_limit, 10)
-
-      option(:retry_backoff, lambda { |context|
-        if context.retries > 1
-          Kernel.sleep(50 * (2 ** (context.retries - 1)) / 1000.0)
-        end
-      })
-
-    end
-  end
-end

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

@@ -1,209 +0,0 @@
-module Aws
-  module Plugins
-
-    # Simplifies working with Amazon DynamoDB attribute values.
-    # Translates attribute values for requests and responses to sensible
-    # Ruby natives.
-    #
-    # This plugin is enabled by default for all {DynamoDB::Client}
-    # objects. You can disable this plugin by passing
-    # `simple_attributes: false` to the client constructor:
-    #
-    #     ddb = Aws::DynamoDB::Client.new(simple_attributes: false)
-    #
-    # ## Input Examples
-    #
-    # With this plugin **enabled**, `simple_attributes: true`:
-    #
-    #     dynamodb.put_item(
-    #       table_name: 'aws-sdk',
-    #       item: {
-    #         id: 'uuid',
-    #         age: 35,
-    #         tags: Set.new(%w(simple attributes)),
-    #         data: StringIO.new('data'),
-    #         scores: [5, 4.5, 4.9, nil],
-    #         name: {
-    #           first: 'John',
-    #           last: 'Doe',
-    #         }
-    #       }
-    #     )
-    #
-    # With this plugin **disabled**, `simple_attributes: false`:
-    #
-    #     # note that all types are prefixed in a hash and that
-    #     # numeric types must be serialized as strings
-    #     dynamodb.put_item(
-    #       table_name: 'aws-sdk',
-    #       item: {
-    #         'id' => { s: 'uuid' },
-    #         'age' => { n: '35' },
-    #         'tags' => { ss: ['simple', 'attributes'] },
-    #         'data' => { b: 'data' },
-    #         'scores' => {
-    #           l: [
-    #             { n: '5' },
-    #             { n: '4.5' },
-    #             { n: '4.9' },
-    #             { null: true },
-    #           ]
-    #         },
-    #         'name' => {
-    #           m: {
-    #             'first' => { s: 'John' },
-    #             'last' => { s: 'Doe' },
-    #           }
-    #         }
-    #       }
-    #     )
-    #
-    # ## Output Examples
-    #
-    # With this plugin **enabled**, `simple_attributes: true`:
-    #
-    #     resp = dynamodb.get(table_name: 'aws-sdk', key: { id: 'uuid' })
-    #     resp.item
-    #     {
-    #       id: 'uuid',
-    #       age: 35,
-    #       tags: Set.new(%w(simple attributes)),
-    #       data: StringIO.new('data'),
-    #       scores: [5, 4.5, 4.9, nil],
-    #       name: {
-    #         first: 'John',
-    #         last: 'Doe',
-    #       }
-    #     }
-    #
-    # With this plugin **disabled**, `simple_attributes: false`:
-    #
-    #     # note that the request `:key` had to be type prefixed
-    #     resp = dynamodb.get(table_name: 'aws-sdk', key: { 'id' => { s: 'uuid' }})
-    #     resp.item
-    #     # {
-    #     #   "id"=> <struct s='uuid', n=nil, b=nil, ss=nil, ns=nil, bs=nil, m=nil, l=nil, null=nil, bool=nil>
-    #     #   "age"=> <struct s=nil, n="35", b=nil, ss=nil, ns=nil, bs=nil, m=nil, l=nil, null=nil, bool=nil>
-    #     #   ...
-    #     # }
-    #
-    # @seahorse.client.option [Boolean] :simple_attributes (true)
-    #   Enables working with DynamoDB attribute values using
-    #   hashes, arrays, sets, integers, floats, booleans, and nil.
-    #
-    #   Disabling this option requires that all attribute values have
-    #   their types specified, e.g. `{ s: 'abc' }` instead of simply
-    #   `'abc'`.
-    #
-    class DynamoDBSimpleAttributes < Seahorse::Client::Plugin
-
-      option(:simple_attributes) { |config| !config.simple_json }
-
-      def add_handlers(handlers, config)
-        if config.simple_attributes
-          handlers.add(Handler, step: :initialize)
-        end
-      end
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          context.params = translate_input(context)
-          @handler.call(context).on(200) do |response|
-            response.data = translate_output(response)
-          end
-        end
-
-        private
-
-        def translate_input(context)
-          if shape = context.operation.input
-            ValueTranslator.new(shape, :marshal).apply(context.params)
-          else
-            context.params
-          end
-        end
-
-        def translate_output(response)
-          if shape = response.context.operation.output
-            ValueTranslator.new(shape, :unmarshal).apply(response.data)
-          else
-            response.data
-          end
-        end
-
-      end
-
-      # @api private
-      class ValueTranslator
-
-        include Seahorse::Model::Shapes
-
-        def self.apply(rules, mode, data)
-          new(rules, mode).apply(data)
-        end
-
-        def initialize(rules, mode)
-          @rules = rules
-          @mode = mode
-        end
-
-        def apply(values)
-          structure(@rules, values) if @rules
-        end
-
-        private
-
-        def structure(ref, values)
-          shape = ref.shape
-          if values.is_a?(Struct)
-            values.members.each do |key|
-              values[key] = translate(shape.member(key), values[key])
-            end
-            values
-          elsif values.is_a?(Hash)
-            values.each.with_object({}) do |(key, value), hash|
-              hash[key] = translate(shape.member(key), value)
-            end
-          else
-            values
-          end
-        end
-
-        def list(ref, values)
-          return values unless values.is_a?(Array)
-          member_ref = ref.shape.member
-          values.inject([]) do |list, value|
-            list << translate(member_ref, value)
-          end
-        end
-
-        def map(ref, values)
-          return values unless values.is_a?(Hash)
-          value_ref = ref.shape.value
-          values.each.with_object({}) do |(key, value), hash|
-            hash[key] = translate(value_ref, value)
-          end
-        end
-
-        def translate(ref, value)
-          if ref.shape.name == 'AttributeValue'
-            DynamoDB::AttributeValue.new.send(@mode, value)
-          else
-            translate_complex(ref, value)
-          end
-        end
-
-        def translate_complex(ref, value)
-          case ref.shape
-          when StructureShape then structure(ref, value)
-          when ListShape then list(ref, value)
-          when MapShape then map(ref, value)
-          else value
-          end
-        end
-
-      end
-    end
-  end
-end