aws-sdk-core 2.0.0.rc1

data/lib/aws/api/service_translators/cloud_front.rb

@@ -0,0 +1,19 @@
+module Aws::Api::ServiceTranslators::CloudFront
+
+  extend Aws::Api::Visitor
+
+  class << self
+
+    def translate(api)
+      convert_max_items(api)
+    end
+
+    # max_item shapes are modeled incorrectly as strings instead of numbers
+    def convert_max_items(api)
+      each_shape(api) do |member_name, shape|
+        shape.type = 'integer' if member_name == :max_items
+      end
+    end
+
+  end
+end

data/lib/aws/api/service_translators/dynamo_db.rb

@@ -0,0 +1,7 @@
+module Aws::Api::ServiceTranslators::DynamoDB
+  class << self
+    def translate(api)
+      api.plugins << "Aws::Plugins::DynamoDBExtendedRetries"
+    end
+  end
+end

data/lib/aws/api/service_translators/glacier.rb

@@ -0,0 +1,37 @@
+module Aws::Api::ServiceTranslators::Glacier
+
+  extend Aws::Api::Visitor
+
+  class << self
+
+    def translate(api)
+      apply_plugins(api)
+      remove_checksum(api)
+      convert_types(api)
+    end
+
+    def apply_plugins(api)
+      api.plugins << "Aws::Plugins::GlacierApiVersion"
+      api.plugins << "Aws::Plugins::GlacierChecksums"
+    end
+
+    # this checksum parameter - it must be calculated on xml that is not user
+    # supplied, so the sdk has to compute the checksum after building the xml
+    def remove_checksum(api)
+      api.operations[:complete_multipart_upload].input.members.delete(:checksum)
+    end
+
+    # Shapes that are bound to headers and the request URI are all typed as
+    # strings, even when they *should* be integers or dates, crawling the
+    # api to correct these
+    def convert_types(api)
+      each_shape(api) do |shape_name, shape|
+        case shape_name
+        when /date/i then shape.type = 'iso8601_timestamp'
+        when :limit, :part_size, :archive_size then shape.type = 'integer'
+        end
+      end
+    end
+
+  end
+end

data/lib/aws/api/service_translators/import_export.rb

@@ -0,0 +1,15 @@
+module Aws::Api::ServiceTranslators::ImportExport
+  class << self
+
+    def translate(api)
+      remove_restful_bindings(api)
+    end
+
+    def remove_restful_bindings(api)
+      api.operations.each do |operation_name, operation|
+        operation.http_path = '/'
+      end
+    end
+
+  end
+end

data/lib/aws/api/service_translators/route53.rb

@@ -0,0 +1,23 @@
+module Aws::Api::ServiceTranslators::Route53
+
+  extend Aws::Api::Visitor
+
+  class << self
+
+    def translate(api)
+      convert_types(api)
+    end
+
+    # Shapes that are bound to headers and the request URI are all typed as
+    # strings, even when they *should* be integers or dates, crawling the
+    # api to correct these
+    def convert_types(api)
+      each_shape(api) do |shape_name, shape|
+        case shape_name
+        when :max_items then shape.type = 'integer'
+        end
+      end
+    end
+
+  end
+end

data/lib/aws/api/service_translators/s3.rb

@@ -0,0 +1,11 @@
+module Aws::Api::ServiceTranslators::S3
+  class << self
+    def translate(api)
+      api.plugins << "Aws::Plugins::S3BucketDns"
+      api.plugins << "Aws::Plugins::S3CompleteMultipartUploadFix"
+      api.plugins << "Aws::Plugins::S3GetBucketLocationFix"
+      api.plugins << "Aws::Plugins::S3Md5s"
+      api.plugins << "Aws::Plugins::S3Redirects"
+    end
+  end
+end

data/lib/aws/api/service_translators/sqs.rb

@@ -0,0 +1,10 @@
+module Aws::Api::ServiceTranslators::SQS
+  class << self
+
+    def translate(api)
+      api.metadata['error_prefix'] = 'AWS.SimpleQueueService.'
+      api.plugins << 'Aws::Plugins::SQSQueueUrls'
+    end
+
+  end
+end

data/lib/aws/api/service_translators/swf.rb

@@ -0,0 +1,7 @@
+module Aws::Api::ServiceTranslators::SWF
+  class << self
+    def translate(api)
+      api.plugins << "Aws::Plugins::SWFReadTimeouts"
+    end
+  end
+end

data/lib/aws/api/shape_translator.rb

@@ -0,0 +1,96 @@
+module Aws
+  module Api
+    class ShapeTranslator < BaseTranslator
+
+      CONVERT_TYPES = {
+        'long' => 'integer',
+        'double' => 'float',
+      }
+
+      def translated
+
+        if @properties['type'] == 'timestamp'
+          @type_prefix = @options[:timestamp_format]
+        end
+
+        if @type_prefix
+          @properties['type'] = "#{@type_prefix}_#{@properties['type']}"
+        end
+
+        shape = Seahorse::Model::Shapes::Shape.from_hash(@properties)
+        shape.members = @members unless @members.nil?
+        shape.keys = @keys if @keys
+        shape
+      end
+
+      property :location
+      property :serialized_name, from: :xmlname
+      property :serialized_name, from: :location_name
+      property :enum
+
+      metadata :xmlnamespace
+      metadata :xmlattribute
+      metadata :payload
+      metadata :wrapper
+
+      ignore :member_order
+      ignore :box
+      ignore :streaming
+
+      # validation properties
+      ignore :pattern
+      ignore :min_length
+      ignore :max_length
+
+      def set_shape_name(shape_name)
+        if @options[:documentation]
+          metadata = @properties['metadata'] ||= {}
+          metadata['shape_name'] = shape_name
+        end
+      end
+
+      def set_xmlnamespace(xmlns)
+        metadata = @properties['metadata'] ||= {}
+        metadata['xmlns_uri'] = xmlns['uri']
+        metadata['xmlns_prefix'] = xmlns['prefix'] if xmlns['prefix']
+      end
+
+      def set_type(type)
+        @properties['type'] = CONVERT_TYPES[type] || type
+      end
+
+      def set_flattened(state)
+        @type_prefix = 'flat' if state
+      end
+
+      def set_keys(member)
+        @keys = self.class.translate(member, @options)
+      end
+
+      # Structure shapes have a hash of members.  Lists and maps have a
+      # single member (with a type).
+      def set_members(members)
+        if members['type'].is_a?(String)
+          @members = self.class.translate(members, @options)
+        else
+          @members = Seahorse::Model::Shapes::MemberHash.new
+          members.each do |name, src|
+            shape = self.class.translate(src, @options)
+            shape.serialized_name ||= name
+            @members[underscore(name)] = shape
+          end
+        end
+      end
+
+    end
+
+    class InputShapeTranslator < ShapeTranslator
+      property :required
+    end
+
+    class OutputShapeTranslator < ShapeTranslator
+      ignore :required
+    end
+
+  end
+end

data/lib/aws/api/translator.rb

@@ -0,0 +1,150 @@
+require 'multi_json'
+
+module Aws
+  module Api
+    class Translator < BaseTranslator
+
+      def self.translate(src, options = {})
+        super(src, options)
+      end
+
+      def translated
+        Seahorse::Model::Api.from_hash(@properties).tap do |api|
+          translate_operations(api)
+          apply_xml_namespaces(api)
+          set_service_names(api)
+          apply_service_customizations(api)
+          sort_metadata_keys(api)
+        end
+      end
+
+      def set_service_names(api)
+        service_namer(api) do |svc|
+          api.metadata['service_full_name'] = svc.full_name
+          api.metadata['service_abbreviation'] = svc.abbr if svc.abbr
+          api.metadata['service_class_name'] = svc.class_name
+        end
+      end
+
+      def sort_metadata_keys(api)
+        api.metadata = Hash[api.metadata.sort]
+      end
+
+      def translate_operations(api)
+        @operations.values.each do |src|
+          operation = OperationTranslator.translate(src, @options)
+          if @result_wrapped
+            operation.output.metadata['wrapper'] = "#{operation.name}Result"
+          end
+          api.operations[underscore(operation.name)] = operation
+        end
+      end
+
+      # XML services, like S3 require the proper XML namespace to be applied
+      # to the root element for each request.  This moves it from the API
+      # metadata into the operation input shape for each operation where
+      # the XML serializer can read it.
+      def apply_xml_namespaces(api)
+        xmlns = api.metadata.delete('xmlnamespace')
+        if xml?
+          api.operations.values.each do |operation|
+            if operation.input.payload
+              operation.input.payload_member.metadata['xmlns_uri'] = xmlns
+            elsif !operation.input.payload_member.members.empty?
+              operation.input.serialized_name = operation.name + "Request"
+              operation.input.metadata['xmlns_uri'] = xmlns
+            end
+          end
+        end
+      end
+
+      def apply_service_customizations(api)
+        svc_name = api.metadata['service_class_name']
+        if ServiceTranslators.const_defined?(svc_name)
+          ServiceTranslators.const_get(svc_name).translate(api)
+        end
+      end
+
+      def service_namer(api)
+        args = []
+        args << api.metadata['endpoint_prefix']
+        args << api.metadata.delete('service_full_name')
+        args << api.metadata.delete('service_abbreviation')
+        yield(Api::ServiceNamer.new(*args))
+      end
+
+      def xml?
+        @properties['plugins'].include?('Aws::Plugins::XmlProtocol')
+      end
+
+      property :version, from: :api_version
+
+      metadata :signing_name
+      metadata :checksum_format
+      metadata :json_version, as: 'json_version'
+      metadata :target_prefix, as: 'json_target_prefix'
+      metadata :service_full_name
+      metadata :service_abbreviation
+      metadata :xmlnamespace
+
+      ignore :global_endpoint
+
+      def set_type(type)
+        plugins = @properties['plugins'] ||= []
+        plugins << 'Seahorse::Client::Plugins::Logging'
+        plugins << 'Seahorse::Client::Plugins::RestfulBindings'
+        plugins << 'Seahorse::Client::Plugins::ContentLength'
+        plugins << 'Aws::Plugins::UserAgent'
+        plugins << 'Aws::Plugins::RetryErrors'
+        plugins << 'Aws::Plugins::GlobalConfiguration'
+        plugins << 'Aws::Plugins::RegionalEndpoint'
+        plugins << 'Aws::Plugins::Credentials'
+        plugins.push(*case type
+          when 'query' then ['Aws::Plugins::QueryProtocol']
+          when 'json' then [
+            'Aws::Plugins::JsonProtocol', # used by all aws json services
+            'Aws::Plugins::JsonRpcHeaders' # not used by services like Glacier
+          ]
+          when /json/ then ['Aws::Plugins::JsonProtocol']
+          when /xml/ then ['Aws::Plugins::XmlProtocol']
+        end)
+      end
+
+      def set_signature_version(version)
+        return unless version
+        @properties['plugins'] ||= []
+        @properties['plugins'] <<
+          case version
+            when 'v4'         then 'Aws::Plugins::SignatureV4'
+            when 'v3'         then 'Aws::Plugins::SignatureV4'
+            when 'v3https'    then 'Aws::Plugins::SignatureV3'
+            when 'v2'         then 'Aws::Plugins::SignatureV2'
+            when 'cloudfront' then 'Aws::Plugins::SignatureV4'
+            when 's3'         then 'Aws::Plugins::S3Signer'
+            else raise "unhandled signer version `#{version}'"
+          end
+      end
+
+      def set_result_wrapped(state)
+        @result_wrapped = state
+      end
+
+      def set_endpoint_prefix(prefix)
+        data = MultiJson.load(File.read('apis/configuration/endpoints.json'))
+        region_names = data['services'][prefix]
+        regions = {}
+        region_names.each do |region|
+          regions[region] = data['regions'][region][prefix]['hostname']
+        end
+        @properties['metadata'] ||= {}
+        @properties['metadata']['endpoint_prefix'] = prefix
+        @properties['metadata']['regional_endpoints'] = regions
+      end
+
+      def set_operations(operations)
+        @operations = operations
+      end
+
+    end
+  end
+end

data/lib/aws/api/visitor.rb

@@ -0,0 +1,32 @@
+module Aws
+  module Api
+    # Visits every shape for every operation in an API model.
+    module Visitor
+
+      include Seahorse::Model::Shapes
+
+      def each_shape(api, &block)
+        api.operations.values.each do |operation|
+          visit_shape(:input, operation.input, &block)
+          visit_shape(:output, operation.output, &block)
+        end
+      end
+
+      def visit_shape(context, shape, &block)
+        yield(context, shape)
+        case shape
+        when StructureShape
+          shape.members.each do |member_name, member_shape|
+            visit_shape(member_name, member_shape, &block)
+          end
+        when MapShape
+          visit_shape(:map_key, shape.keys, &block)
+          visit_shape(:map_value, shape.members, &block)
+        when ListShape
+          visit_shape(:list_member, shape.members, &block)
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/credentials.rb

@@ -0,0 +1,35 @@
+module Aws
+  class Credentials
+
+    # @param [String] access_key_id
+    # @param [String] secret_access_key
+    # @param [String] session_token (nil)
+    def initialize(access_key_id, secret_access_key, session_token = nil)
+      @access_key_id = access_key_id
+      @secret_access_key = secret_access_key
+      @session_token = session_token
+    end
+
+    # @return [String, nil]
+    attr_accessor :access_key_id
+
+    # @return [String, nil]
+    attr_accessor :secret_access_key
+
+    # @return [String, nil]
+    attr_accessor :session_token
+
+    # @return [Boolean] Returns `true` if the access key id and secret
+    #   access key are both set.
+    def set?
+      !!(@access_key_id && @secret_access_key)
+    end
+
+    # Removing the secret access key from the default inspect string.
+    # @api private
+    def inspect
+      "#<#{self.class.name} access_key_id=#{access_key_id}>"
+    end
+
+  end
+end