aws-sdk-core 2.2.37 → 2.3.0

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

@@ -0,0 +1,60 @@
+module Aws
+  module Partitions
+    # @api private
+    class PartitionList
+
+      include Enumerable
+
+      def initialize
+        @partitions = {}
+      end
+
+      def clear
+        @partitions = {}
+      end
+
+      # @return [Enumerator<Partition>]
+      def each(&block)
+        @partitions.each_value(&block)
+      end
+
+      # @param [String] partition_name
+      # @return [Partition]
+      def partition(partition_name)
+        if @partitions.key?(partition_name)
+          @partitions[partition_name]
+        else
+          msg = "invalid partition name #{partition_name.inspect}; valid "
+          msg << "partition names include %s" % [@partitions.keys.join(', ')]
+          raise ArgumentError, msg
+        end
+      end
+
+      # @return [Array<Partition>]
+      def partitions
+        @partitions.values
+      end
+
+      # @param [Partition] partition
+      def add_partition(partition)
+        if Partition === partition
+          @partitions[partition.name] = partition
+        else
+          raise ArgumentError, "expected Partition, got #{partition.class}"
+        end
+      end
+
+      class << self
+
+        # @api private
+        def build(partitions)
+          partitions['partitions'].inject(PartitionList.new) do |list, partition|
+            list.add_partition(Partition.build(partition))
+            list
+          end
+        end
+
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,73 @@
+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)
+
+      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)
+          use_accelerate_endpoint(context) if context[:use_accelerate_endpoint]
+          @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 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/stub_responses.rb

@@ -15,7 +15,7 @@ module Aws
       option(:stub_responses, false)
 
       option(:region) do |config|
-        'stubbed-region' if config.stub_responses
+        'us-stubbed-1' if config.stub_responses
       end
 
       option(:credentials) do |config|

data/lib/aws-sdk-core/signers/s3.rb

@@ -12,6 +12,7 @@ module Aws
         acl delete cors lifecycle location logging notification partNumber
         policy requestPayment restore tagging torrent uploadId uploads
         versionId versioning versions website replication requestPayment
+        accelerate
 
         response-content-type response-content-language
         response-expires response-cache-control

data/lib/aws-sdk-core/signers/v4.rb

@@ -42,7 +42,7 @@ module Aws
       def initialize(credentials, service_name, region)
         @service_name = service_name
         @credentials = credentials.credentials
-        @region = region
+        @region = EndpointProvider.signing_region(region, service_name)
       end
 
       # @param [Seahorse::Client::Http::Request] req

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

@@ -1,3 +1,3 @@
 module Aws
-  VERSION = '2.2.37'
+  VERSION = '2.3.0'
 end

data/service-models.json

@@ -0,0 +1,273 @@
+{
+  "ACM": {
+    "models": "acm/2015-12-08",
+    "endpoint": "acm"
+  },
+  "APIGateway": {
+    "models": "apigateway/2015-07-09",
+    "endpoint": "apigateway"
+  },
+  "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/2015-10-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"
+  },
+  "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"
+  }
+}