aws-sdk-core 2.3.23 → 3.89.1

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

@@ -1,6 +0,0 @@
-Aws.add_service(:APIGateway, {
-  api: "#{Aws::API_DIR}/apigateway/2015-07-09/api-2.json",
-  docs: "#{Aws::API_DIR}/apigateway/2015-07-09/docs-2.json",
-  examples: "#{Aws::API_DIR}/apigateway/2015-07-09/examples-1.json",
-  paginators: "#{Aws::API_DIR}/apigateway/2015-07-09/paginators-1.json",
-})

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

@@ -1,6 +0,0 @@
-Aws.add_service(:ApplicationAutoScaling, {
-  api: "#{Aws::API_DIR}/application-autoscaling/2016-02-06/api-2.json",
-  docs: "#{Aws::API_DIR}/application-autoscaling/2016-02-06/docs-2.json",
-  examples: "#{Aws::API_DIR}/application-autoscaling/2016-02-06/examples-1.json",
-  paginators: "#{Aws::API_DIR}/application-autoscaling/2016-02-06/paginators-1.json",
-})

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

@@ -1,5 +0,0 @@
-Aws.add_service(:ApplicationDiscoveryService, {
-  api: "#{Aws::API_DIR}/discovery/2015-11-01/api-2.json",
-  docs: "#{Aws::API_DIR}/discovery/2015-11-01/docs-2.json",
-  examples: "#{Aws::API_DIR}/discovery/2015-11-01/examples-1.json",
-})

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

@@ -1,8 +0,0 @@
-Aws.add_service(:AutoScaling, {
-  api: "#{Aws::API_DIR}/autoscaling/2011-01-01/api-2.json",
-  docs: "#{Aws::API_DIR}/autoscaling/2011-01-01/docs-2.json",
-  examples: "#{Aws::API_DIR}/autoscaling/2011-01-01/examples-1.json",
-  paginators: "#{Aws::API_DIR}/autoscaling/2011-01-01/paginators-1.json",
-  resources: "#{Aws::API_DIR}/autoscaling/2011-01-01/resources-1.json",
-  waiters: "#{Aws::API_DIR}/autoscaling/2011-01-01/waiters-2.json",
-})

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

@@ -1,51 +0,0 @@
-require 'openssl'
-require 'tempfile'
-
-module Aws
-  # @api private
-  module Checksums
-
-    CHUNK_SIZE = 1 * 1024 * 1024 # one MB
-
-    class << self
-
-      # @param [File, Tempfile, IO#read, String] value
-      # @return [String<SHA256 Hexdigest>]
-      def sha256_hexdigest(value)
-        if File === value || Tempfile === value
-          OpenSSL::Digest::SHA256.file(value).hexdigest
-        elsif value.respond_to?(:read)
-          sha256 = OpenSSL::Digest::SHA256.new
-          update_in_chunks(sha256, value)
-          sha256.hexdigest
-        else
-          OpenSSL::Digest::SHA256.hexdigest(value)
-        end
-      end
-
-      # @param [File, Tempfile, IO#read, String] value
-      # @return [String<MD5>]
-      def md5(value)
-        if File === value || Tempfile === value
-          Base64.encode64(OpenSSL::Digest::MD5.file(value).digest).strip
-        elsif value.respond_to?(:read)
-          md5 = OpenSSL::Digest::MD5.new
-          update_in_chunks(md5, value)
-          Base64.encode64(md5.digest).strip
-        else
-          Base64.encode64(OpenSSL::Digest::MD5.digest(value)).strip
-        end
-      end
-
-      private
-
-      def update_in_chunks(digest, io)
-        while chunk = io.read(CHUNK_SIZE)
-          digest.update(chunk)
-        end
-        io.rewind
-      end
-
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-module Aws
-  # Base class for all {Aws} service clients.
-  class Client < Seahorse::Client::Base
-
-    # @api private
-    DEFAULT_PLUGINS = [
-      'Seahorse::Client::Plugins::ContentLength',
-      'Aws::Plugins::Logging',
-      'Aws::Plugins::ParamConverter',
-      'Aws::Plugins::ParamValidator',
-      'Aws::Plugins::UserAgent',
-      'Aws::Plugins::RetryErrors',
-      'Aws::Plugins::GlobalConfiguration',
-      'Aws::Plugins::RegionalEndpoint',
-      'Aws::Plugins::RequestSigner',
-      'Aws::Plugins::ResponsePaging',
-      'Aws::Plugins::StubResponses',
-    ]
-
-    # @api private
-    PROTOCOL_PLUGINS = Hash.new(DEFAULT_PLUGINS).merge({
-      'json'      => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::JsonRpc),
-      'rest-json' => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::RestJson),
-      'rest-xml'  => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::RestXml),
-      'query'     => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::Query),
-      'ec2'       => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::EC2),
-    })
-
-    include ClientStubs
-    include ClientWaiters
-
-    class << self
-
-      # @return [Symbol]
-      # @api private
-      attr_accessor :identifier
-
-      # @api private
-      def define(svc_name, options)
-        client_class = Class.new(self)
-        client_class.identifier = svc_name.downcase.to_sym
-        client_class.set_api(Api::Builder.build(options[:api], options))
-        client_class.set_waiters(options[:waiters])
-
-        protocol = client_class.api.metadata['protocol']
-        PROTOCOL_PLUGINS[protocol].each do |plugin|
-          client_class.add_plugin(plugin)
-        end
-
-        Api::Customizations.apply_plugins(client_class)
-
-        soft_deprecation
-        client_class
-      end
-
-      private
-
-      def soft_deprecation
-        unless @warned
-          @warned = true
-          warn('NEWER VERSION AVAILABLE: Please upgrade to AWS SDK For Ruby V3')
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,120 +0,0 @@
-module Aws
-  module ClientWaiters
-
-    # @api private
-    def self.included(subclass)
-      class << subclass
-
-        def set_waiters(waiters)
-          @waiters =
-            case waiters
-            when Waiters::Provider then waiters
-            when Hash then Waiters::Provider.new(waiters)
-            when String, Pathname then Waiters::Provider.new(Json.load_file(waiters))
-            when nil then Waiters::NullProvider.new
-            else raise ArgumentError, 'invalid waiters'
-            end
-        end
-
-        def waiters
-          @waiters
-        end
-
-      end
-    end
-
-    # Waiters polls an API operation until a resource enters a desired
-    # state.
-    #
-    # ## Basic Usage
-    #
-    # Waiters will poll until they are succesful, they fail by
-    # entering a terminal state, or until a maximum number of attempts
-    # are made.
-    #
-    #    # polls in a loop, sleeping between attempts
-    #    client.waiter_until(waiter_name, params)
-    #
-    # ## Configuration
-    #
-    # You can configure the maximum number of polling attempts, and the
-    # delay (in seconds) between each polling attempt. You configure
-    # waiters by passing a block to {#wait_until}:
-    #
-    #     # poll for ~25 seconds
-    #     client.wait_until(...) do |w|
-    #       w.max_attempts = 5
-    #       w.delay = 5
-    #     end
-    #
-    # ## Callbacks
-    #
-    # You can be notified before each polling attempt and before each
-    # delay. If you throw `:success` or `:failure` from these callbacks,
-    # it will terminate the waiter.
-    #
-    #     started_at = Time.now
-    #     client.wait_until(...) do |w|
-    #
-    #       # disable max attempts
-    #       w.max_attempts = nil
-    #
-    #       # poll for 1 hour, instead of a number of attempts
-    #       w.before_wait do |attempts, response|
-    #         throw :failure if Time.now - started_at > 3600
-    #       end
-    #
-    #     end
-    #
-    # ## Handling Errors
-    #
-    # When a waiter is successful, it returns `true`. When a waiter
-    # fails, it raises an error. **All errors raised extend from
-    # {Aws::Waiters::Errors::WaiterFailed}**.
-    #
-    #   begin
-    #     client.wait_until(...)
-    #   rescue Aws::Waiters::Errors::WaiterFailed
-    #     # resource did not enter the desired state in time
-    #   end
-    #
-    # @param [Symbol] waiter_name The name of the waiter. See {#waiter_names}
-    #   for a full list of supported waiters.
-    #
-    # @param [Hash] params Additional request parameters. See the {#waiter_names}
-    #   for a list of supported waiters and what request they call. The
-    #   called request determines the list of accepted parameters.
-    #
-    # @yieldparam [Waiters::Waiter] waiter Yields a {Waiters::Waiter Waiter}
-    #   object that can be configured prior to waiting.
-    #
-    # @raise [Errors::FailureStateError] Raised when the waiter terminates
-    #   because the waiter has entered a state that it will not transition
-    #   out of, preventing success.
-    #
-    # @raise [Errors::TooManyAttemptsError] Raised when the configured
-    #   maximum number of attempts have been made, and the waiter is not
-    #   yet successful.
-    #
-    # @raise [Errors::UnexpectedError] Raised when an error is encounted
-    #   while polling for a resource that is not expected.
-    #
-    # @raise [Errors::NoSuchWaiterError] Raised when you request to wait
-    #   for an unknown state.
-    #
-    # @return [Boolean] Returns `true` if the waiter was successful.
-    #
-    def wait_until(waiter_name, params = {}, &block)
-      waiter = self.class.waiters.waiter(waiter_name)
-      yield(waiter) if block_given?
-      waiter.wait(client:self, params:params)
-    end
-
-    # Returns the list of supported waiters.
-    # @return [Array<Symbol>]
-    def waiter_names
-      self.class.waiters.waiter_names
-    end
-
-  end
-end

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

@@ -1,8 +0,0 @@
-Aws.add_service(:CloudFormation, {
-  api: "#{Aws::API_DIR}/cloudformation/2010-05-15/api-2.json",
-  docs: "#{Aws::API_DIR}/cloudformation/2010-05-15/docs-2.json",
-  examples: "#{Aws::API_DIR}/cloudformation/2010-05-15/examples-1.json",
-  paginators: "#{Aws::API_DIR}/cloudformation/2010-05-15/paginators-1.json",
-  resources: "#{Aws::API_DIR}/cloudformation/2010-05-15/resources-1.json",
-  waiters: "#{Aws::API_DIR}/cloudformation/2010-05-15/waiters-2.json",
-})

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

@@ -1,15 +0,0 @@
-Aws.add_service(:CloudFront, {
-  api: "#{Aws::API_DIR}/cloudfront/2016-01-28/api-2.json",
-  docs: "#{Aws::API_DIR}/cloudfront/2016-01-28/docs-2.json",
-  examples: "#{Aws::API_DIR}/cloudfront/2016-01-28/examples-1.json",
-  paginators: "#{Aws::API_DIR}/cloudfront/2016-01-28/paginators-1.json",
-  waiters: "#{Aws::API_DIR}/cloudfront/2016-01-28/waiters-2.json",
-})
-
-module Aws
-  module CloudFront
-
-    autoload :UrlSigner, 'aws-sdk-core/cloudfront/url_signer.rb'
-
-  end
-end

data/lib/aws-sdk-core/cloudfront/url_signer.rb

@@ -1,167 +0,0 @@
-require 'base64'
-require 'uri'
-require 'time'
-require 'json'
-require 'openssl'
-
-module Aws
-  module CloudFront
-
-    # Allows you to create signed URLs for Amazon CloudFront resources
-    #
-    #     signer = Aws::CloudFront::UrlSigner.new
-    #     url = signer.signed_url(url,
-    #       key_pair_id: "cf-keypair-id",
-    #       private_key_path: "./cf_private_key.pem"
-    #     )
-    #
-    class UrlSigner
-
-      # @option options [String] :key_pair_id
-      # @option options [String] :private_key
-      # @option options [String] :private_key_path
-      def initialize(options = {})
-        @key_pair_id = key_pair_id(options)
-        @private_key = private_key(options)
-      end
-
-      # create a signed Amazon CloudFront URL
-      # @param [String] url
-      # @option params [Time, DateTime, Date, String, Integer<timestamp>] :expires
-      # @option params [String<JSON>] :policy
-      def signed_url(url, params = {})
-        url_sections = url.split('://')
-        if url_sections.length < 2
-          raise ArgumentError, "Invaild URL:#{url}"
-        end
-        # removing wildcard character to get real scheme
-        scheme = url_sections[0].gsub('*', '')
-        uri = "#{scheme}://#{url_sections[1]}"
-        signed_content = signature(
-          :resource => resource(scheme, uri),
-          :expires => time(params[:expires]),
-          :policy => params[:policy]
-        )
-
-        start_flag = URI.parse(uri).query ? '&' : '?'
-        uri = "#{uri}#{start_flag}#{signed_content}"
-
-        if scheme == 'rtmp'
-          rtmp_url(URI(uri))
-        else
-          uri
-        end
-      end
-
-      private
-
-      def time(expires)
-        case expires
-        when Time then expires.to_i
-        when DateTime, Date then expires.to_time.to_i
-        when String then Time.parse(expires).to_i
-        when Integer, NIL then expires
-        else
-          msg = "expected a time value for :expires, got `#{expires.class}'"
-          raise ArgumentError, msg
-        end
-      end
-
-      # create a relative signed URL for RTMP distribution
-      def rtmp_url(uri)
-        result = uri.path.gsub(' ', '/')
-        result[0] = ''
-        if uri.query
-          "#{result}?#{uri.query}"
-        else
-          result
-        end
-      end
-
-      # prepare resource for signing
-      def resource(scheme, url)
-        case scheme
-        when 'http', 'http*', 'https' then url
-        when 'rtmp'
-          url_info = URI.parse(url)
-          path = url_info.path
-          path[0] = ''
-          resource_content = "#{File.dirname(path)}/#{File.basename(path)}".gsub(' ', '/')
-          if url_info.query
-            "#{resource_content}?#{uri.query}"
-          else
-            resource_content
-          end
-        else
-          msg = "Invaild URI scheme:#{scheme}.Scheme must be one of: http, https or rtmp."
-          raise ArgumentError, msg
-        end
-      end
-
-      # create signed values that used to construct signed URLs
-      # @option param [String] :resource
-      # @option param [Integer<timestamp>] :expires
-      # @option param [String<JSON>] :policy
-      def signature(params = {})
-        signature_content = []
-        if params[:policy]
-          policy = params[:policy].gsub('/\s/s', '')
-          signature_content << "Policy=#{encode(policy)}"
-        elsif params[:resource] && params[:expires]
-          policy = canned_policy(params[:resource], params[:expires])
-          signature_content << "Expires=#{params[:expires]}"
-        else
-          msg = "Either a policy or a resource with an expiration time must be provided."
-          raise ArgumentError, msg
-        end
-
-        signature_content << "Signature=#{encode(sign_policy(policy))}"
-        signature_content << "Key-Pair-Id=#{@key_pair_id}"
-        signature_content.join('&').gsub("\n", '')
-      end
-
-      # create the signature string with policy signed
-      def sign_policy(policy)
-        key = OpenSSL::PKey::RSA.new(@private_key)
-        key.sign(OpenSSL::Digest::SHA1.new, policy)
-      end
-
-      # create canned policy that used for signing
-      def canned_policy(resource, expires)
-        json_hash = {
-          'Statement' => [
-            'Resource' => resource,
-              'Condition' => {
-                'DateLessThan' => {'AWS:EpochTime' => expires}
-              }
-          ]
-        }
-        json_hash.to_json
-      end
-
-      def encode(policy)
-        Base64.encode64(policy).gsub(/[+=\/]/, '+' => '-', '=' => '_', '/' => '~')
-      end
-
-      def key_pair_id(options)
-        if options[:key_pair_id].nil? or options[:key_pair_id] == ''
-          raise ArgumentError, ":key_pair_id must not be blank"
-        else
-          options[:key_pair_id]
-        end
-      end
-
-      def private_key(options)
-        if options[:private_key]
-          options[:private_key]
-        elsif options[:private_key_path]
-          File.open(options[:private_key_path], 'rb') { |f| f.read }
-        else
-          msg = ":private_key or :private_key_path should be provided"
-          raise ArgumentError, msg
-        end
-      end
-
-    end
-  end
-end