aws-sdk-core 2.9.44 → 3.1.0

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

@@ -1,87 +0,0 @@
-require 'openssl'
-
-module Aws
-  module Plugins
-
-    # Computes the `:checksum` of the HTTP request body for operations
-    # that require the `X-Amz-Sha256-Tree-Hash` header.  This includes:
-    #
-    # * `:complete_multipart_upload`
-    # * `:upload_archive`
-    # * `:upload_multipart_part`
-    #
-    # The `:upload_archive` and `:upload_multipart_part` operations
-    # accept a `:checksum` request parameter.  If this param
-    # is present, then the checksum is assumed to be the proper
-    # tree hash of the file to be uploaded.  If this param is
-    # not present, then the required tree hash checksum will
-    # be generated.
-    #
-    # The `:complete_multipart_upload` operation does not accept
-    # a checksum and this plugin will always compute this of the
-    # HTTP request body on your behalf.
-    class GlacierChecksums < Seahorse::Client::Plugin
-
-      CHECKSUM_OPERATIONS = [
-        :upload_archive,
-        :upload_multipart_part,
-      ]
-
-      class Handler < Seahorse::Client::Handler
-
-        HASH = 'X-Amz-Content-Sha256'
-
-        TREE_HASH = 'X-Amz-Sha256-Tree-Hash'
-
-        def call(context)
-          unless context.http_request.headers[TREE_HASH]
-            populate_checksum_headers(context)
-          end
-          @handler.call(context)
-        end
-
-        private
-
-        def populate_checksum_headers(context)
-          compute_checksums(context.http_request.body) do |hash, tree_hash|
-            context.http_request.headers[HASH] = hash
-            context.http_request.headers[TREE_HASH] = tree_hash.digest
-            context[:tree_hash] = tree_hash
-          end
-        end
-
-        # Computes two checksums of the body.  The tree hash is required
-        # by Glacier for operations where you upload a file.  The other
-        # checksum is required by signature version 4.  We compute both
-        # here so the sigv4 signer does not need to re-read the body.
-        def compute_checksums(body, &block)
-
-          tree_hash = TreeHash.new
-          digest = OpenSSL::Digest.new('sha256')
-
-          # if the body is empty/EOF, then we should compute the
-          # digests of the empty string
-          if body.size == 0
-            tree_hash.update('')
-            digest.update('')
-          end
-
-          # Rewind body before performing checksum computation.
-          body.rewind
-
-          while chunk = body.read(1024 * 1024) # read 1MB
-            tree_hash.update(chunk)
-            digest.update(chunk)
-          end
-          body.rewind
-
-          yield(digest.to_s, tree_hash)
-
-        end
-      end
-
-      handler(Handler, operations: CHECKSUM_OPERATIONS)
-
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Aws
-  module Plugins
-    # @api private
-    class MachineLearningPredictEndpoint < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          endpoint = context.params.delete(:predict_endpoint)
-          context.http_request.endpoint = URI.parse(endpoint.to_s)
-          @handler.call(context)
-        end
-
-      end
-
-      handle(Handler, operations: [:predict])
-
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-require 'aws-sigv4'
-
-module Aws
-  module Plugins
-
-    # This plugin populates the `:pre_signed_url` request param for the
-    # CopyDBSnapshot API.
-    #
-    # This parameter is required by RDS when copying an encrypted snapshot
-    # across regions. This plugin will be skipped if the `:pre_signed_url`
-    # parameter is provided by the user.
-    #
-    # @seahorse.client.option [String] :source_region The region which you are
-    #  copying an encrypted snapshot from. This parameter must be present to
-    #  have the plugin compute a presigned URL on your behalf.
-    class RDSCrossRegionCopying < Seahorse::Client::Plugin
-
-      # @api private
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          params = context.params
-          if params[:source_region] && !params[:pre_signed_url]
-            params[:pre_signed_url] = presigned_url(context, params)
-            params[:destination_region] = context.config.region
-          end
-          @handler.call(context)
-        end
-
-        private
-        def presigned_url(context, params)
-          # :source_region is not modeled in the api
-          source_region = params.delete(:source_region)
-          param_list = Aws::Query::ParamList.new
-          param_list.set('Action', context.operation.name)
-          param_list.set('DestinationRegion', context.config.region)
-          param_list.set('Version', context.config.api.metadata['apiVersion'])
-          Aws::Query::ParamBuilder.new(param_list).apply(
-            context.operation.input,
-            params
-          )
-          signer = Aws::Sigv4::Signer.new(
-            service: 'rds',
-            region: source_region,
-            credentials_provider: context.config.credentials
-          )
-          url = Aws::EndpointProvider.resolve(signer.region, 'rds')
-          url += "?#{param_list.to_s}"
-          signer.presign_url(
-            http_method: 'GET',
-            url: url,
-            body: '',
-            expires_in: 3600
-          ).to_s
-        end
-      end
-      handler(
-        Handler,
-        step: :initialize,
-        operations: [
-          :copy_db_snapshot,
-          :create_db_instance_read_replica,
-          :copy_db_cluster_snapshot,
-          :create_db_cluster
-        ]
-      )
-    end
-  end
-end

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

@@ -1,150 +0,0 @@
-module Aws
-  module Plugins
-
-    # @seahorse.client.option [required, Credentials] :credentials Your
-    #   AWS credentials.  The following locations will be searched in order
-    #   for credentials:
-    #
-    #   * `:access_key_id`, `:secret_access_key`, and `:session_token` options
-    #   * ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
-    #   * `HOME/.aws/credentials` shared credentials file
-    #   * EC2 instance profile credentials
-    #
-    # @seahorse.client.option [String] :profile Used when loading credentials
-    #   from the shared credentials file at HOME/.aws/credentials.  When not
-    #   specified, 'default' is used.
-    #
-    # @seahorse.client.option [String] :access_key_id Used to set credentials
-    #   statically.
-    #
-    # @seahorse.client.option [String] :secret_access_key Used to set
-    #   credentials statically.
-    #
-    # @seahorse.client.option [String] :session_token Used to set credentials
-    #   statically.
-    #
-    class RequestSigner < Seahorse::Client::Plugin
-
-      option(:access_key_id)
-
-      option(:secret_access_key)
-
-      option(:session_token)
-
-      option(:profile)
-
-      option(:credentials) do |config|
-        CredentialProviderChain.new(config).resolve
-      end
-
-      option(:instance_profile_credentials_retries, 0)
-
-      option(:instance_profile_credentials_timeout, 1)
-
-      # Intentionally not documented - this should go away when all
-      # services support signature version 4 in every region.
-      option(:signature_version) do |cfg|
-        cfg.api.metadata['signatureVersion']
-      end
-
-      option(:sigv4_name) do |cfg|
-        cfg.api.metadata['signingName'] || cfg.api.metadata['endpointPrefix']
-      end
-
-      option(:sigv4_region) do |cfg|
-        prefix = cfg.api.metadata['endpointPrefix']
-        if prefix.nil?
-          cfg.region
-        elsif cfg.endpoint.to_s.match(/#{prefix}\.amazonaws\.com/)
-          'us-east-1'
-        else
-          cfg.region
-        end
-      end
-
-      class Handler < Seahorse::Client::Handler
-
-        SIGNERS = {
-          'v4'      => Signers::V4,
-          'v3https' => Signers::V3,
-          'v2'      => Signers::V2,
-          's3'      => Signers::S3,
-        }
-
-        STS_UNSIGNED_REQUESTS = Set.new(%w(
-          AssumeRoleWithSAML
-          AssumeRoleWithWebIdentity
-        ))
-
-        COGNITO_IDENTITY_UNSIGNED_REQUESTS = Set.new(%w(
-          GetCredentialsForIdentity
-          GetId
-          GetOpenIdToken
-          UnlinkIdentity
-        ))
-
-        def call(context)
-          sign_authenticated_requests(context) unless unsigned_request?(context)
-          @handler.call(context)
-        end
-
-        private
-
-        def sign_authenticated_requests(context)
-          require_credentials(context)
-          if signer = SIGNERS[context.config.signature_version]
-            require_credentials(context)
-            signer.sign(apply_authtype(context))
-          end
-        end
-
-        def require_credentials(context)
-          if missing_credentials?(context)
-            msg = 'unable to sign request without credentials set'
-            raise Errors::MissingCredentialsError, msg
-          end
-        end
-
-        def missing_credentials?(context)
-          context.config.credentials.nil? or
-          !context.config.credentials.set?
-        end
-
-        def unsigned_request?(context)
-          if context.config.api.metadata['endpointPrefix'] == 'sts'
-            STS_UNSIGNED_REQUESTS.include?(context.operation.name)
-          elsif context.config.api.metadata['endpointPrefix'] == 'cloudsearchdomain'
-            context.config.credentials.nil? || !context.config.credentials.set?
-          elsif context.config.api.metadata['endpointPrefix'] == 'cognito-identity'
-            COGNITO_IDENTITY_UNSIGNED_REQUESTS.include?(context.operation.name)
-          else
-            false
-          end
-        end
-
-        def apply_authtype(context)
-          if context.operation['authtype'].eql?('v4-unsigned-body') &&
-            context.http_request.endpoint.scheme.eql?('https')
-            context.http_request.headers['X-Amz-Content-Sha256'] = 'UNSIGNED-PAYLOAD'
-          end
-          context
-        end
-
-      end
-
-      def add_handlers(handlers, config)
-        # See the S3RequestSignerPlugin for Amazon S3 signature logic
-        unless config.sigv4_name == 's3'
-          operations = []
-          config.api.operation_names.each do |operation_name|
-            if config.api.operation(operation_name)['authtype'] != 'none'
-              operations << operation_name
-            end
-          end
-          handlers.add(Handler, step: :sign, operations: operations)
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-module Aws
-  module Plugins
-
-    # The Amazon Route 53 API returns hosted zones and request Ids as strings
-    # formatted like:
-    #
-    #     '/hostedzone/ID'
-    #     '/change/ID'
-    #
-    # However, their API does not accept Ids with the '/hostedzone/' or
-    # '/change/' prefixes. This plugin removes those prefixes before
-    # serializing their Ids onto the request. This allows a user to
-    # use the prefixed Ids returned in {Aws::Route53::Client} responses.
-    class Route53IdFix < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          remove_id_prefixes(context.params)
-          @handler.call(context)
-        end
-
-        private
-
-        def remove_id_prefixes(params)
-          # Many operations accept of :id or :hosted_zone_id as a root-level
-          # param, pruning prefixes from those.
-          [:id, :hosted_zone_id, :delegation_set_id].each do |key|
-            params[key] = remove_prefix(params[key]) if params[key]
-          end
-
-          # The `#change_resource_record_sets operation` has a deeply nested
-          # target with a :hosted_zone_id that needs to be pruned.
-          if params[:change_batch]
-            params[:change_batch][:changes].each do |batch|
-              if target = batch[:resource_record_set][:alias_target]
-                target[:hosted_zone_id] = remove_prefix(target[:hosted_zone_id])
-              end
-            end
-          end
-        end
-
-        def remove_prefix(str)
-          str.sub(/^\/(hostedzone|change|delegationset)\//, '')
-        end
-
-      end
-
-      # Run this handler after params have been validated, but before
-      # they are serialized onto the request
-      handler(Handler, priority: 99, step: :build)
-
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-module Aws
-  module Plugins
-
-    # Provides support for using `Aws::S3::Client` with Amazon S3 Transfer
-    # Acceleration.
-    #
-    # Go here for more information about transfer acceleration:
-    # [http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html](http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html)
-    #
-    # @seahorse.client.option [Boolean] :use_accelerate_endpoint (false)
-    #   When set to `true`, accelerated bucket endpoints will be used
-    #   for all object operations. You must first enable
-    #   accelerate for each bucket. [Go here for more information](http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html).
-    #
-    class S3Accelerate < Seahorse::Client::Plugin
-
-      option(:use_accelerate_endpoint, false)
-      option(:use_dualstack_endpoint, false)
-
-      def add_handlers(handlers, config)
-        operations = config.api.operation_names - [
-          :create_bucket, :list_buckets, :delete_bucket,
-        ]
-        handlers.add(OptionHandler, step: :initialize, operations: operations)
-        handlers.add(AccelerateHandler, step: :build, priority: 0, operations: operations)
-      end
-
-      # @api private
-      class OptionHandler < Seahorse::Client::Handler
-        def call(context)
-          accelerate = context.params.delete(:use_accelerate_endpoint)
-          accelerate = context.config.use_accelerate_endpoint if accelerate.nil?
-          context[:use_accelerate_endpoint] = accelerate
-          @handler.call(context)
-        end
-      end
-
-      # @api private
-      class AccelerateHandler < Seahorse::Client::Handler
-
-        def call(context)
-          if context[:use_accelerate_endpoint]
-            if context[:use_dualstack_endpoint]
-              use_combined_accelerate_dualstack_endpoint(context)
-            else
-              use_accelerate_endpoint(context)
-            end
-          end
-          @handler.call(context)
-        end
-
-        private
-
-        def use_accelerate_endpoint(context)
-          bucket_name = context.params[:bucket]
-          validate_bucket_name!(bucket_name)
-          endpoint = URI.parse(context.http_request.endpoint.to_s)
-          endpoint.scheme = 'https'
-          endpoint.port = 443
-          endpoint.host = "#{bucket_name}.s3-accelerate.amazonaws.com"
-          context.http_request.endpoint = endpoint.to_s
-        end
-
-        def use_combined_accelerate_dualstack_endpoint(context)
-          bucket_name = context.params[:bucket]
-          validate_bucket_name!(bucket_name)
-          endpoint = URI.parse(context.http_request.endpoint.to_s)
-          endpoint.scheme = 'https'
-          endpoint.port = 443
-          endpoint.host = "#{bucket_name}.s3-accelerate.dualstack.amazonaws.com"
-          context.http_request.endpoint = endpoint.to_s
-        end
-
-        def validate_bucket_name!(bucket_name)
-          unless S3BucketDns.dns_compatible?(bucket_name, ssl = true)
-            msg = "unable to use `accelerate: true` on buckets with "
-            msg << "non-DNS compatible names"
-            raise ArgumentError, msg
-          end
-          if bucket_name.include?('.')
-            msg = "unable to use `accelerate: true` on buckets with dots"
-            msg << "in their name: #{bucket_name.inspect}"
-            raise ArgumentError, msg
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-module Aws
-  module Plugins
-
-    # Amazon S3 requires DNS style addressing for buckets outside of
-    # the classic region when possible.
-    #
-    # @seahorse.client.option [Boolean] :force_path_style (false)
-    #   When set to `true`, the bucket name is always left in the
-    #   request URI and never moved to the host as a sub-domain.
-    #
-    class S3BucketDns < Seahorse::Client::Plugin
-
-      # When set to `false` DNS compatible bucket names are moved from
-      # the request URI path to the host as a subdomain, unless the request
-      # is using SSL and the bucket name contains a dot.
-      #
-      # When set to `true`, the bucket name is always forced to be part
-      # of the request URI path.  This will not work with buckets outside
-      # the classic region.
-      option(:force_path_style, false)
-
-      def add_handlers(handlers, config)
-        handlers.add(Handler) unless config.force_path_style
-      end
-
-      # @api private
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          move_dns_compat_bucket_to_subdomain(context)
-          @handler.call(context)
-        end
-
-        private
-
-        def move_dns_compat_bucket_to_subdomain(context)
-          bucket_name = context.params[:bucket]
-          endpoint = context.http_request.endpoint
-          if
-            bucket_name &&
-            S3BucketDns.dns_compatible?(bucket_name, https?(endpoint)) &&
-            context.operation_name.to_s != 'get_bucket_location'
-          then
-            move_bucket_to_subdomain(bucket_name, endpoint)
-          end
-        end
-
-        def move_bucket_to_subdomain(bucket_name, endpoint)
-          endpoint.host = "#{bucket_name}.#{endpoint.host}"
-          path = endpoint.path.sub("/#{bucket_name}", '')
-          path = "/#{path}" unless path.match(/^\//)
-          endpoint.path = path
-        end
-
-        def https?(uri)
-          uri.scheme == 'https'
-        end
-
-      end
-
-      class << self
-
-        # @param [String] bucket_name
-        # @param [Boolean] ssl
-        # @return [Boolean]
-        def dns_compatible?(bucket_name, ssl)
-          if valid_subdomain?(bucket_name)
-            bucket_name.match(/\./) && ssl ? false : true
-          else
-            false
-          end
-        end
-
-        private
-
-        def valid_subdomain?(bucket_name)
-          bucket_name.size < 64 &&
-          bucket_name =~ /^[a-z0-9][a-z0-9.-]+[a-z0-9]$/ &&
-          bucket_name !~ /(\d+\.){3}\d+/ &&
-          bucket_name !~ /[.-]{2}/
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Aws
-  module Plugins
-    # @api private
-    class S3BucketNameRestrictions < Seahorse::Client::Plugin
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          if context.params.key?(:bucket) && context.params[:bucket].include?('/')
-            msg = ":bucket option must not contain a forward-slash (/)"
-            raise ArgumentError, msg
-          end
-          @handler.call(context)
-        end
-
-      end
-
-      handler(Handler)
-
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-module Aws
-  module Plugins
-
-    # @api private
-    # @seahorse.client.option [Boolean] :use_dualstack_endpoint (false)
-    #   When set to `true`, IPv6-compatible bucket endpoints will be used
-    #   for all operations.
-    class S3Dualstack < Seahorse::Client::Plugin
-
-      option(:use_dualstack_endpoint, false)
-      option(:use_accelerate_endpoint, false)
-
-      def add_handlers(handlers, config)
-        handlers.add(OptionHandler, step: :initialize)
-        handlers.add(DualstackHandler, step: :build, priority: 0)
-      end
-
-      # @api private
-      class OptionHandler < Seahorse::Client::Handler
-        def call(context)
-          dualstack = context.params.delete(:use_dualstack_endpoint)
-          dualstack = context.config.use_dualstack_endpoint if dualstack.nil?
-          context[:use_dualstack_endpoint] = dualstack
-          @handler.call(context)
-        end
-      end
-
-      # @api private
-      class DualstackHandler < Seahorse::Client::Handler
-        def call(context)
-          apply_dualstack_endpoint(context) if use_dualstack_endpoint?(context)
-          @handler.call(context)
-        end
-
-        private
-        def apply_dualstack_endpoint(context)
-          bucket_name = context.params[:bucket]
-          region = context.config.region
-          force_path_style = context.config.force_path_style
-          dns_suffix = EndpointProvider.dns_suffix_for(region)
-
-          if use_bucket_dns?(bucket_name, context)
-            host = "#{bucket_name}.s3.dualstack.#{region}.#{dns_suffix}"
-          else
-            host = "s3.dualstack.#{region}.#{dns_suffix}"
-          end
-          endpoint = URI.parse(context.http_request.endpoint.to_s)
-          endpoint.scheme = context.http_request.endpoint.scheme
-          endpoint.port = context.http_request.endpoint.port
-          endpoint.host = host
-          context.http_request.endpoint = endpoint.to_s
-        end
-
-        def use_bucket_dns?(bucket_name, context)
-          ssl = context.http_request.endpoint.scheme == "https"
-          bucket_name && S3BucketDns.dns_compatible?(bucket_name, ssl) &&
-            !context.config.force_path_style
-        end
-
-        def use_dualstack_endpoint?(context)
-          context[:use_dualstack_endpoint] && !context[:use_accelerate_endpoint]
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module Aws
-  module Plugins
-    class S3Expect100Continue < Seahorse::Client::Plugin
-
-      def add_handlers(handlers, config)
-        if config.http_continue_timeout && config.http_continue_timeout > 0
-          handlers.add(Handler)
-        end
-      end
-
-      # @api private
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          if
-            context.http_request.body &&
-            context.http_request.body.size > 0
-          then
-            context.http_request.headers['expect'] = '100-continue'
-          end
-          @handler.call(context)
-        end
-
-      end
-    end
-  end
-end