aws-sdk-core 2.11.632 → 3.0.0.rc1

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

@@ -1,56 +0,0 @@
-require 'aws-sigv4'
-
-module Aws
-  module Plugins
-
-    # This plugin auto populates the following request params for the
-    # CopySnapshot API:
-    #
-    # * `:destination_region`
-    # * `:presigned_url`
-    #
-    # These params are required by EC2 when copying an encrypted snapshot.
-    class EC2CopyEncryptedSnapshot < Seahorse::Client::Plugin
-
-      # @api private
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          params = context.params
-          params[:destination_region] = context.config.region
-          params[:presigned_url] = presigned_url(context, params)
-          @handler.call(context)
-        end
-
-        private
-
-        def presigned_url(context, params)
-          param_list = Aws::Query::ParamList.new
-          param_list.set('Action', 'CopySnapshot')
-          param_list.set('DestinationRegion', context.config.region)
-          param_list.set('Version', context.config.api.metadata['apiVersion'])
-          Aws::Query::EC2ParamBuilder.new(param_list).apply(context.operation.input, params)
-
-          signer = Aws::Sigv4::Signer.new(
-            service: 'ec2',
-            region: params[:source_region],
-            credentials_provider: context.config.credentials
-          )
-          url = Aws::EndpointProvider.resolve(signer.region, 'ec2')
-          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_snapshot])
-
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Aws
-  module Plugins
-    # @api private
-    class EC2RegionValidation < Seahorse::Client::Plugin
-
-      def after_initialize(client)
-        if region = client.config.region
-          if matches = region.match(/^(\w+-\w+-\d+)[a-z]$/)
-            msg = ":region option must a region name, not an availability "
-            msg << "zone name; try `#{matches[1]}' instead of `#{matches[0]}'"
-            raise ArgumentError, msg
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,167 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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/glacier_account_id.rb

@@ -1,19 +0,0 @@
-module Aws
-  module Plugins
-
-    # @seahorse.client.option [String] :account_id ('-')
-    #   The default Glacier AWS account ID to use for all glacier
-    #   operations. The default value of `-` uses the account
-    #   your `:credentials` belong to.
-    #
-    class GlacierAccountId < Seahorse::Client::Plugin
-
-      option :account_id, '-'
-
-      handle_request(step: :initialize) do |context|
-        context.params[:account_id] ||= context.config.account_id
-      end
-
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Aws
-  module Plugins
-    class GlacierApiVersion < Seahorse::Client::Plugin
-
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          version = context.config.api.version
-          context.http_request.headers['x-amz-glacier-version'] = version
-          @handler.call(context)
-        end
-
-      end
-
-      handler(Handler)
-
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module Aws
-  module Plugins
-
-    # Converts input value to JSON Syntax for members with jsonvalue trait
-    class JsonvalueConverter < Seahorse::Client::Plugin
-
-      # @api private
-      class Handler < Seahorse::Client::Handler
-
-        def call(context)
-          context.operation.input.shape.members.each do |m, ref|
-            if ref['jsonvalue']
-              param_value = context.params[m]
-              unless param_value.respond_to?(:to_json)
-                raise ArgumentError, "The value of params[#{m}] is not JSON serializable."
-              end
-              context.params[m] = param_value.to_json
-            end
-          end
-          @handler.call(context)
-        end
-
-      end
-
-      handler(Handler, step: :initialize)
-    end
-
-  end
-end