aws-sdk-core 2.4.0 → 3.53.0

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

@@ -1,5 +0,0 @@
-Aws.add_service(:SimpleDB, {
-  api: "#{Aws::API_DIR}/sdb/2009-04-15/api-2.json",
-  docs: "#{Aws::API_DIR}/sdb/2009-04-15/docs-2.json",
-  paginators: "#{Aws::API_DIR}/sdb/2009-04-15/paginators-1.json",
-})

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

@@ -1,6 +0,0 @@
-Aws.add_service(:SNS, {
-  api: "#{Aws::API_DIR}/sns/2010-03-31/api-2.json",
-  docs: "#{Aws::API_DIR}/sns/2010-03-31/docs-2.json",
-  paginators: "#{Aws::API_DIR}/sns/2010-03-31/paginators-1.json",
-  resources: "#{Aws::API_DIR}/sns/2010-03-31/resources-1.json",
-})

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

@@ -1,6 +0,0 @@
-Aws.add_service(:SQS, {
-  api: "#{Aws::API_DIR}/sqs/2012-11-05/api-2.json",
-  docs: "#{Aws::API_DIR}/sqs/2012-11-05/docs-2.json",
-  examples: "#{Aws::API_DIR}/sqs/2012-11-05/examples-1.json",
-  paginators: "#{Aws::API_DIR}/sqs/2012-11-05/paginators-1.json",
-})

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

@@ -1,6 +0,0 @@
-Aws.add_service(:SSM, {
-  api: "#{Aws::API_DIR}/ssm/2014-11-06/api-2.json",
-  docs: "#{Aws::API_DIR}/ssm/2014-11-06/docs-2.json",
-  examples: "#{Aws::API_DIR}/ssm/2014-11-06/examples-1.json",
-  paginators: "#{Aws::API_DIR}/ssm/2014-11-06/paginators-1.json",
-})

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

@@ -1,6 +0,0 @@
-Aws.add_service(:StorageGateway, {
-  api: "#{Aws::API_DIR}/storagegateway/2013-06-30/api-2.json",
-  docs: "#{Aws::API_DIR}/storagegateway/2013-06-30/docs-2.json",
-  examples: "#{Aws::API_DIR}/storagegateway/2013-06-30/examples-1.json",
-  paginators: "#{Aws::API_DIR}/storagegateway/2013-06-30/paginators-1.json",
-})

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

@@ -1,5 +0,0 @@
-Aws.add_service(:STS, {
-  api: "#{Aws::API_DIR}/sts/2011-06-15/api-2.json",
-  docs: "#{Aws::API_DIR}/sts/2011-06-15/docs-2.json",
-  examples: "#{Aws::API_DIR}/sts/2011-06-15/examples-1.json",
-})

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

@@ -1,5 +0,0 @@
-Aws.add_service(:Support, {
-  api: "#{Aws::API_DIR}/support/2013-04-15/api-2.json",
-  docs: "#{Aws::API_DIR}/support/2013-04-15/docs-2.json",
-  paginators: "#{Aws::API_DIR}/support/2013-04-15/paginators-1.json",
-})

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

@@ -1,5 +0,0 @@
-Aws.add_service(:SWF, {
-  api: "#{Aws::API_DIR}/swf/2012-01-25/api-2.json",
-  docs: "#{Aws::API_DIR}/swf/2012-01-25/docs-2.json",
-  paginators: "#{Aws::API_DIR}/swf/2012-01-25/paginators-1.json",
-})

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

@@ -1,69 +0,0 @@
-require 'openssl'
-
-module Aws
-
-  # Used for computing a tree hash SHA256 checksum of an object.
-  #
-  #    tree_hash = TreeHash.new
-  #    tree_hash.update(file.read(1024 * 1024)) until file.eof?
-  #    tree_hash.digest
-  #
-  # == Limitations and Notes
-  #
-  # There are two main limitations to be aware of when using TreeHash:
-  #
-  # * TreeHash is not thread safe. Use multiple TreeHash objects to concurrently
-  #   compute a tree hash of a large object.  Join their hashes at the end into
-  #   a single TreeHash and then call {#digest}
-  #
-  #      TreeHash.new(tree_hashes.map(&:hashes).flatten)
-  #
-  # * You must call {#update} with 1MB chunks of data.  Only the final
-  #   chunk may be smaller than 1MB.
-  #
-  # If you have a large object/file, and you would like to compute the
-  # chunks concurrently, you must break the original file/data into sections
-  # that are evenly divisible by 1MB.  Each section of data requires
-  # a seperate TreeHash object to compute hashes.  Once all sections of
-  # data are complete, you can rejoin their {#hashes} in sequential order
-  # into a single TreeHash, then call {#digest} on the final tree hash.
-  #
-  class TreeHash
-
-    def initialize(hashes = [])
-      @digest = OpenSSL::Digest.new('sha256')
-      @hashes = hashes
-    end
-
-    # @return [Array<String>] The built up list of hashes.  Each hash is
-    #   a sha255 digest of a 1MB chunk.
-    attr_accessor :hashes
-
-    # @param [String] chunk
-    # @return [String] Returns the computed SHA256 digest of the chunk.
-    def update(chunk)
-      @hashes << @digest.update(chunk).digest
-      @digest.reset
-      @hashes.last
-    end
-
-    def digest
-      hashes = @hashes
-      digest = OpenSSL::Digest.new('sha256')
-      until hashes.count == 1
-        hashes = hashes.each_slice(2).map do |h1,h2|
-          digest.reset
-          if h2
-            digest.update(h1)
-            digest.update(h2)
-            digest.digest
-          else
-            h1
-          end
-        end
-      end
-      hashes.first.bytes.map{|x| x.to_i.to_s(16).rjust(2, '0')}.join('')
-    end
-
-  end
-end

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

@@ -1,3 +0,0 @@
-module Aws
-  VERSION = '2.4.0'
-end

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

@@ -1,5 +0,0 @@
-Aws.add_service(:WAF, {
-  api: "#{Aws::API_DIR}/waf/2015-08-24/api-2.json",
-  docs: "#{Aws::API_DIR}/waf/2015-08-24/docs-2.json",
-  examples: "#{Aws::API_DIR}/waf/2015-08-24/examples-1.json",
-})

data/lib/aws-sdk-core/waiters/null_provider.rb

@@ -1,12 +0,0 @@
-module Aws
-  module Waiters
-    # @api private
-    class NullProvider < Provider
-
-      def initialize
-        super('waiters' => {})
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-core/waiters/provider.rb

@@ -1,35 +0,0 @@
-module Aws
-  module Waiters
-    # @api private
-    class Provider
-
-      def initialize(definitions)
-        @waiters = {}
-        definitions['waiters'].each do |waiter_name, definition|
-          @waiters[Seahorse::Util.underscore(waiter_name).to_sym] = {
-            poller: Poller.new(definition),
-            max_attempts: definition['maxAttempts'],
-            delay: definition['delay'],
-          }
-        end
-      end
-
-      # @return [Array<Symbol>]
-      def waiter_names
-        @waiters.keys
-      end
-
-      # @param [Symbol] waiter_name
-      # @return [Waiter]
-      # @raise [ArgumentError]
-      def waiter(waiter_name)
-        if @waiters.key?(waiter_name)
-          Waiter.new(@waiters[waiter_name])
-        else
-          raise Errors::NoSuchWaiterError.new(waiter_name, waiter_names)
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,6 +0,0 @@
-Aws.add_service(:WorkSpaces, {
-  api: "#{Aws::API_DIR}/workspaces/2015-04-08/api-2.json",
-  docs: "#{Aws::API_DIR}/workspaces/2015-04-08/docs-2.json",
-  examples: "#{Aws::API_DIR}/workspaces/2015-04-08/examples-1.json",
-  paginators: "#{Aws::API_DIR}/workspaces/2015-04-08/paginators-1.json",
-})

data/lib/seahorse/client/plugins/restful_bindings.rb

@@ -1,127 +0,0 @@
-require 'cgi'
-
-module Seahorse
-  module Client
-    module Plugins
-      # @api private
-      class RestfulBindings < Plugin
-
-        # @api private
-        class Handler < Client::Handler
-
-          include Seahorse::Model::Shapes
-
-          def call(context)
-            build_request(context)
-            @handler.call(context).on(200..299) do |response|
-              parse_response(response)
-            end
-          end
-
-          private
-
-          # Populates the HTTP request method and headers.
-          def build_request(context)
-            populate_http_request_method(context)
-            populate_http_headers(context)
-          end
-
-          def populate_http_request_method(context)
-            context.http_request.http_method = context.operation.http_method
-          end
-
-          def populate_http_headers(context)
-            params = context.params
-            headers = context.http_request.headers
-            each_member(context.operation.input) do |member_name, member_ref|
-              value = params[member_name]
-              next if value.nil?
-              case member_ref.location
-              when 'header'  then serialize_header(headers, member_ref, value)
-              when 'headers' then serialize_header_map(headers, member_ref, value)
-              end
-            end
-          end
-
-          def serialize_header(headers, ref, value)
-            headers[ref.location_name] = serialize_header_value(ref, value)
-          end
-
-          def serialize_header_map(headers, ref, values)
-            prefix = ref.location_name || ''
-            values.each_pair do |name, value|
-              value = serialize_header_value(ref.shape.value, value)
-              headers["#{prefix}#{name}"] = value
-            end
-          end
-
-          def serialize_header_value(ref, value)
-            if TimestampShape === ref.shape
-              value.utc.httpdate
-            else
-              value.to_s
-            end
-          end
-
-          # Extracts HTTP response headers and status code.
-          def parse_response(response)
-            headers = response.context.http_response.headers
-            each_member(response.context.operation.output) do |key, ref|
-              case ref.location
-              when 'statusCode'
-                status_code = response.context.http_response.status_code
-                response.data[key] = status_code
-              when 'header'
-                if headers.key?(ref.location_name)
-                  response.data[key] = extract_header(headers, ref)
-                end
-              when 'headers'
-                response.data[key] = extract_header_map(headers, ref)
-              end
-            end
-          end
-
-          def extract_header(headers, ref)
-            parse_header_value(ref, headers[ref.location_name])
-          end
-
-          def extract_header_map(headers, ref)
-            prefix = ref.location_name || ''
-            hash = {}
-            headers.each do |header, value|
-              if match = header.match(/^#{prefix}(.+)/i)
-                hash[match[1]] = parse_header_value(ref.shape.value, value)
-              end
-            end
-            hash
-          end
-
-          def parse_header_value(ref, value)
-            if value
-              case ref.shape
-              when IntegerShape then value.to_i
-              when FloatShape then value.to_f
-              when BooleanShape then value == 'true'
-              when TimestampShape
-                if value =~ /\d+(\.\d*)/
-                  Time.at(value.to_f)
-                else
-                  Time.parse(value)
-                end
-              else value
-              end
-            end
-          end
-
-          def each_member(ref, &block)
-            ref.shape.members.each(&block) if ref
-          end
-
-        end
-
-        handle(Handler, priority: 90)
-
-      end
-    end
-  end
-end

data/service-models.json

@@ -1,285 +0,0 @@
-{
-  "ACM": {
-    "models": "acm/2015-12-08",
-    "endpoint": "acm"
-  },
-  "APIGateway": {
-    "models": "apigateway/2015-07-09",
-    "endpoint": "apigateway"
-  },
-  "ApplicationAutoScaling": {
-    "models": "application-autoscaling/2016-02-06",
-    "endpoint": "application-autoscaling"
-  },
-  "ApplicationDiscoveryService": {
-    "models": "discovery/2015-11-01",
-    "endpoint": "discovery"
-  },
-  "AutoScaling": {
-    "models": "autoscaling/2011-01-01",
-    "endpoint": "autoscaling"
-  },
-  "CloudFormation": {
-    "models": "cloudformation/2010-05-15",
-    "endpoint": "cloudformation"
-  },
-  "CloudFront": {
-    "models": "cloudfront/2016-01-28",
-    "endpoint": "cloudfront"
-  },
-  "CloudHSM": {
-    "models": "cloudhsm/2014-05-30",
-    "endpoint": "cloudhsm"
-  },
-  "CloudSearch": {
-    "models": "cloudsearch/2013-01-01",
-    "endpoint": "cloudsearch"
-  },
-  "CloudSearchDomain": {
-    "models": "cloudsearchdomain/2013-01-01"
-  },
-  "CloudTrail": {
-    "models": "cloudtrail/2013-11-01",
-    "endpoint": "cloudtrail"
-  },
-  "CloudWatch": {
-    "models": "monitoring/2010-08-01",
-    "endpoint": "monitoring"
-  },
-  "CloudWatchEvents": {
-    "models": "events/2015-10-07",
-    "endpoint": "events"
-  },
-  "CloudWatchLogs": {
-    "models": "logs/2014-03-28",
-    "endpoint": "logs"
-  },
-  "CodeCommit": {
-    "models": "codecommit/2015-04-13",
-    "endpoint": "codecommit"
-  },
-  "CodeDeploy": {
-    "models": "codedeploy/2014-10-06",
-    "endpoint": "codedeploy"
-  },
-  "CodePipeline": {
-    "models": "codepipeline/2015-07-09",
-    "endpoint": "codepipeline"
-  },
-  "CognitoIdentity": {
-    "models": "cognito-identity/2014-06-30",
-    "endpoint": "cognito-identity"
-  },
-  "CognitoIdentityProvider": {
-    "models": "cognito-idp/2016-04-18",
-    "endpoint": "cognito-idp"
-  },
-  "CognitoSync": {
-    "models": "cognito-sync/2014-06-30",
-    "endpoint": "cognito-sync"
-  },
-  "ConfigService": {
-    "models": "config/2014-11-12",
-    "endpoint": "config"
-  },
-  "DatabaseMigrationService": {
-    "models": "dms/2016-01-01",
-    "endpoint": "dms"
-  },
-  "DataPipeline": {
-    "models": "datapipeline/2012-10-29",
-    "endpoint": "datapipeline"
-  },
-  "DeviceFarm": {
-    "models": "devicefarm/2015-06-23",
-    "endpoint": "devicefarm"
-  },
-  "DirectConnect": {
-    "models": "directconnect/2012-10-25",
-    "endpoint": "directconnect"
-  },
-  "DirectoryService": {
-    "models": "ds/2015-04-16",
-    "endpoint": "ds"
-  },
-  "DynamoDB": {
-    "models": "dynamodb/2012-08-10",
-    "endpoint": "dynamodb"
-  },
-  "DynamoDBStreams": {
-    "models": "streams.dynamodb/2012-08-10",
-    "endpoint": "streams.dynamodb"
-  },
-  "EC2": {
-    "models": "ec2/2016-04-01",
-    "endpoint": "ec2"
-  },
-  "ECR": {
-    "models": "ecr/2015-09-21",
-    "endpoint": "ecr"
-  },
-  "ECS": {
-    "models": "ecs/2014-11-13",
-    "endpoint": "ecs"
-  },
-  "EFS": {
-    "models": "elasticfilesystem/2015-02-01",
-    "endpoint": "elasticfilesystem"
-  },
-  "ElastiCache": {
-    "models": "elasticache/2015-02-02",
-    "endpoint": "elasticache"
-  },
-  "ElasticBeanstalk": {
-    "models": "elasticbeanstalk/2010-12-01",
-    "endpoint": "elasticbeanstalk"
-  },
-  "ElasticLoadBalancing": {
-    "models": "elasticloadbalancing/2012-06-01",
-    "endpoint": "elasticloadbalancing"
-  },
-  "ElasticsearchService": {
-    "models": "es/2015-01-01",
-    "endpoint": "es"
-  },
-  "ElasticTranscoder": {
-    "models": "elastictranscoder/2012-09-25",
-    "endpoint": "elastictranscoder"
-  },
-  "EMR": {
-    "models": "elasticmapreduce/2009-03-31",
-    "endpoint": "elasticmapreduce"
-  },
-  "Firehose": {
-    "models": "firehose/2015-08-04",
-    "endpoint": "firehose"
-  },
-  "GameLift": {
-    "models": "gamelift/2015-10-01",
-    "endpoint": "gamelift"
-  },
-  "Glacier": {
-    "models": "glacier/2012-06-01",
-    "endpoint": "glacier"
-  },
-  "IAM": {
-    "models": "iam/2010-05-08",
-    "endpoint": "iam"
-  },
-  "ImportExport": {
-    "models": "importexport/2010-06-01",
-    "endpoint": "importexport"
-  },
-  "Inspector": {
-    "models": "inspector/2016-02-16",
-    "endpoint": "inspector"
-  },
-  "IoT": {
-    "models": "iot/2015-05-28",
-    "endpoint": "iot"
-  },
-  "IoTDataPlane": {
-    "models": "iot-data/2015-05-28",
-    "endpoint": "data.iot"
-  },
-  "Kinesis": {
-    "models": "kinesis/2013-12-02",
-    "endpoint": "kinesis"
-  },
-  "KMS": {
-    "models": "kms/2014-11-01",
-    "endpoint": "kms"
-  },
-  "Lambda": {
-    "models": "lambda/2015-03-31",
-    "endpoint": "lambda"
-  },
-  "LambdaPreview": {
-    "models": "lambda/2014-11-11",
-    "endpoint": "lambda"
-  },
-  "MachineLearning": {
-    "models": "machinelearning/2014-12-12",
-    "endpoint": "machinelearning"
-  },
-  "MarketplaceCommerceAnalytics": {
-    "models": "marketplacecommerceanalytics/2015-07-01",
-    "endpoint": "marketplacecommerceanalytics"
-  },
-  "MarketplaceMetering": {
-    "models": "meteringmarketplace/2016-01-14",
-    "endpoint": "metering.marketplace"
-  },
-  "OpsWorks": {
-    "models": "opsworks/2013-02-18",
-    "endpoint": "opsworks"
-  },
-  "RDS": {
-    "models": "rds/2014-10-31",
-    "endpoint": "rds"
-  },
-  "Redshift": {
-    "models": "redshift/2012-12-01",
-    "endpoint": "redshift"
-  },
-  "Route53": {
-    "models": "route53/2013-04-01",
-    "endpoint": "route53"
-  },
-  "Route53Domains": {
-    "models": "route53domains/2014-05-15",
-    "endpoint": "route53domains"
-  },
-  "S3": {
-    "models": "s3/2006-03-01",
-    "endpoint": "s3"
-  },
-  "ServiceCatalog": {
-    "models": "servicecatalog/2015-12-10",
-    "endpoint": "servicecatalog"
-  },
-  "SES": {
-    "models": "email/2010-12-01",
-    "endpoint": "email"
-  },
-  "SimpleDB": {
-    "models": "sdb/2009-04-15",
-    "endpoint": "sdb"
-  },
-  "SNS": {
-    "models": "sns/2010-03-31",
-    "endpoint": "sns"
-  },
-  "SQS": {
-    "models": "sqs/2012-11-05",
-    "endpoint": "sqs"
-  },
-  "SSM": {
-    "models": "ssm/2014-11-06",
-    "endpoint": "ssm"
-  },
-  "StorageGateway": {
-    "models": "storagegateway/2013-06-30",
-    "endpoint": "storagegateway"
-  },
-  "STS": {
-    "models": "sts/2011-06-15",
-    "endpoint": "sts"
-  },
-  "Support": {
-    "models": "support/2013-04-15",
-    "endpoint": "support"
-  },
-  "SWF": {
-    "models": "swf/2012-01-25",
-    "endpoint": "swf"
-  },
-  "WAF": {
-    "models": "waf/2015-08-24",
-    "endpoint": "waf"
-  },
-  "WorkSpaces": {
-    "models": "workspaces/2015-04-08",
-    "endpoint": "workspaces"
-  }
-}