aws-sdk-core 2.0.0.rc1

data/lib/aws/timestamp_formatter.rb

@@ -0,0 +1,16 @@
+module Aws
+  # @api private
+  module TimestampFormatter
+
+    include Seahorse::Model::Shapes
+
+    def timestamp(shape, value)
+      value = case shape
+        when Iso8601TimestampShape then value.iso8601
+        when Rfc822TimestampShape then value.rfc822
+        when UnixTimestampShape then value.to_i
+        else raise "invalid timestamp format `#{shape.class.name}'"
+      end
+    end
+  end
+end

data/lib/aws/util.rb

@@ -0,0 +1,38 @@
+require 'cgi'
+
+module Aws
+  # @api private
+  module Util
+
+    # @param [String] string
+    # @return [String] Returns the underscored version of the given string.
+    def underscore(string)
+      inflector = Hash.new do |hash, key|
+        key.
+          gsub(/([A-Z0-9]+)([A-Z][a-z])/, '\1_\2'). # split acronyms
+          scan(/[a-z]+|\d+|[A-Z0-9]+[a-z]*/).       # split words
+          join('_').downcase                        # join parts
+      end
+
+      # add a few irregular inflections
+      inflector['ETag'] = 'etag'
+      inflector['s3Bucket'] = 's3_bucket'
+      inflector['s3Key'] = 's3_key'
+      inflector['Ec2KeyName'] = 'ec2_key_name'
+      inflector['Ec2SubnetId'] = 'ec2_subnet_id'
+      inflector['Ec2VolumeId'] = 'ec2_volume_id'
+      inflector['Ec2InstanceId'] = 'ec2_instance_id'
+      inflector['ElastiCache'] = 'elasticache'
+      inflector['NotificationARNs'] = 'notification_arns'
+
+      inflector[string]
+    end
+    module_function :underscore
+
+    def uri_escape(string)
+      CGI::escape(string.encode('UTF-8')).gsub('+', '%20').gsub('%7E', '~')
+    end
+    module_function :uri_escape
+
+  end
+end

data/lib/aws/version.rb

@@ -0,0 +1,3 @@
+module Aws
+  VERSION = '2.0.0.rc1'
+end

data/lib/aws/xml/builder.rb

@@ -0,0 +1,134 @@
+require 'builder'
+require 'base64'
+
+module Aws
+  module Xml
+    # @api private
+    class Builder
+
+      include Seahorse::Model::Shapes
+      include TimestampFormatter
+
+      # @param [Seahorse::Model::Shapes::Shape] rules
+      def initialize(rules)
+        @xml = []
+        @builder = ::Builder::XmlMarkup.new(target: @xml, indent: 2)
+        @rules = rules
+      end
+
+      # @param [Hash] params
+      # @return [String] Returns an XML doc string.
+      def to_xml(params)
+        structure(@rules.serialized_name, @rules, params) unless params.empty?
+        @xml.join
+      end
+
+      class << self
+
+        # @param [Seahorse::Model::Shapes::Shape] rules
+        # @param [Hash] params
+        # @return [String] Returns an XML doc string.
+        def to_xml(rules, params)
+          new(rules).to_xml(params)
+        end
+        alias build to_xml
+
+      end
+
+      private
+
+      def structure(name, shape, values)
+        if values.empty?
+         node(name, shape)
+        else
+          node(name, shape, structure_attrs(shape, values)) do
+            shape.members.each_pair do |member_name, member_shape|
+              unless values[member_name].nil?
+                next if xml_attribute?(member_shape)
+                mname = member_shape.serialized_name
+                member(mname, member_shape, values[member_name])
+              end
+            end
+          end
+        end
+      end
+
+      def structure_attrs(shape, values)
+        shape.members.inject({}) do |attrs, (member_name, member_shape)|
+          if xml_attribute?(member_shape) && values.key?(member_name)
+            attrs[member_shape.serialized_name] = values[member_name]
+          end
+          attrs
+        end
+      end
+
+      def list(name, shape, values)
+        if flat?(shape)
+          values.each do |value|
+            member(name, shape.members, value)
+          end
+        else
+          node(name, shape) do
+            values.each do |value|
+              mname = shape.members.serialized_name || 'member'
+              member(mname, shape.members, value)
+            end
+          end
+        end
+      end
+
+      def member(name, shape, value)
+        case shape
+        when StructureShape then structure(name, shape, value)
+        when ListShape then list(name, shape, value)
+        else node(name, shape, format(shape, value))
+        end
+      end
+
+      def format(shape, value)
+        case shape
+        when TimestampShape then timestamp(shape, value.utc)
+        when BlobShape then Base64.strict_encode64(value)
+        else value.to_s
+        end
+      end
+
+      # The `args` list may contain:
+      #
+      #   * [] - empty, no value or attributes
+      #   * [value] - inline element, no attributes
+      #   * [value, attributes_hash] - inline element with attributes
+      #   * [attributes_hash] - self closing element with attributes
+      #
+      # Pass a block if you want to nest XML nodes inside.  When doing this,
+      # you may *not* pass a value to the `args` list.
+      #
+      def node(name, shape, *args, &block)
+        attrs = args.last.is_a?(Hash) ? args.pop : {}
+        attrs = shape_attrs(shape).merge(attrs)
+        args << attrs
+        @builder.__send__(name, *args, &block)
+      end
+
+      def shape_attrs(shape)
+        if xmlns = shape.metadata['xmlns_uri']
+          prefix = shape.metadata['xmlns_prefix']
+          attribute = 'xmlns'
+          attribute += ':' + prefix if prefix
+          { attribute => xmlns }
+        else
+          {}
+        end
+      end
+
+      def xml_attribute?(shape)
+        !!shape.metadata['xmlattribute']
+      end
+
+      def flat?(shape)
+        FlatListShape === shape || FlatMapShape === shape
+      end
+
+    end
+  end
+end

data/lib/aws/xml/error_parser.rb

@@ -0,0 +1,24 @@
+module Aws
+  module Xml
+    class ErrorParser
+
+      def extract_error(response)
+        error = MultiXml.parse(response.http_response.body_contents)
+        %w(Response ErrorResponse Errors Error).each do |wrapper|
+          error = error[wrapper] if error[wrapper]
+        end
+        [remove_prefix(response, error['Code']), error['Message']]
+      end
+
+      def remove_prefix(response, error_code)
+        prefix = response.context.config.api.metadata['error_prefix']
+        if prefix = response.context.config.api.metadata['error_prefix']
+          error_code.sub(/^#{prefix}/, '')
+        else
+          error_code
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/xml/parser.rb

@@ -0,0 +1,147 @@
+require 'multi_xml'
+require 'time'
+require 'base64'
+
+module Aws
+  module Xml
+    # @api private
+    class Parser
+
+      include Seahorse::Model::Shapes
+
+      # @param [Seahorse::Model::Shapes::OutputShape] output
+      # @param [String<xml>] xml
+      # @return [Hash]
+      def parse(output, xml)
+        rules = apply_wrapper(output)
+        result = structure(rules, MultiXml.parse(xml).values.first || {})
+        remove_wrapper(output, result)
+      end
+
+      # @param [Seahorse::Model::Shapes::OutputShape] rules
+      # @param [String<xml>] xml
+      # @return [Hash]
+      def self.parse(rules, xml)
+        new.parse(rules, xml)
+      end
+
+      private
+
+      def apply_wrapper(shape)
+        if wrapper_name = shape.metadata['wrapper']
+          wrapper = Seahorse::Model::Shapes::OutputShape.new
+          wrapper.serialized_name = wrapper_name
+          wrapper.members[wrapper_name] = shape
+          wrapper
+        else
+          shape
+        end
+      end
+
+      def remove_wrapper(shape, data)
+        if wrapper_name = shape.metadata['wrapper']
+          data[wrapper_name]
+        else
+          data
+        end
+      end
+
+      def structure(shape, hash)
+        data = Structure.new(shape.members.keys)
+        shape.members.each do |member_name, member_shape|
+          key = member_xmlname(member_shape)
+          data[member_name] = member(member_shape, hash[key])
+        end
+        data
+      end
+
+      def list(shape, values)
+        member_shape = shape.members
+        unless flat?(shape)
+          values = values[member_shape.serialized_name || 'member']
+        end
+        values = [values] unless values.is_a?(Array)
+        values.map { |value| member(member_shape, value) }
+      end
+
+      def map(shape, entries)
+        key_shape = shape.keys
+        value_shape = shape.members
+        data = {}
+        entries = entries['entry'] unless flat?(shape)
+        entries = [entries] unless entries.is_a?(Array)
+        entries.each do |entry|
+          key = entry[key_shape.serialized_name || 'key']
+          value = entry[value_shape.serialized_name || 'value']
+          data[member(key_shape, key)] = member(value_shape, value)
+        end
+        data
+      end
+
+      def member_xmlname(shape)
+        if shape.is_a?(FlatListShape)
+          shape.members.serialized_name || shape.serialized_name
+        else
+          shape.serialized_name
+        end
+      end
+
+      def member(shape, raw)
+        if raw.nil?
+          case shape
+          when StructureShape then Structure.new(shape.members.keys)
+          when MapShape then {}
+          when ListShape then []
+          else nil
+          end
+        else
+          case shape
+          when StringShape then string(shape, raw)
+          when StructureShape then structure(shape, raw)
+          when ListShape then list(shape, raw)
+          when MapShape then map(shape, raw)
+          when BooleanShape then raw == 'true'
+          when IntegerShape then raw.to_i
+          when FloatShape then raw.to_f
+          when TimestampShape then timestamp(raw)
+          when BlobShape then Base64.decode64(raw)
+          else raw
+          end
+        end
+      end
+
+      def string(shape, raw)
+        if raw.is_a?(Hash)
+          decode_string(raw)
+        else
+          raw
+        end
+      end
+
+      def decode_string(raw)
+        case raw['encoding']
+        when 'base64' then Base64.decode64(raw['__content__'])
+        else raw['__content__']
+        end
+      end
+
+      def timestamp(raw)
+        case raw
+        when nil then nil
+        when /^\d+$/ then Time.at(raw.to_i)
+        else
+          begin
+            Time.parse(raw)
+          rescue ArgumentError
+            raise "unhandled timestamp format `#{raw}'"
+          end
+        end
+      end
+
+      def flat?(shape)
+        FlatListShape === shape || FlatMapShape === shape
+      end
+
+    end
+  end
+end

data/lib/aws/xml/serializer.rb

@@ -0,0 +1,16 @@
+module Aws
+  module Xml
+    # @api private
+    class Serializer
+
+      def setup_request(context)
+        context.http_request.headers['Content-Type'] = 'application/xml'
+      end
+
+      def serialize_params(context, rules, params)
+        context.http_request.body = Builder.build(rules, params)
+      end
+
+    end
+  end
+end

data/spec/aws/credentials_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Aws
+  describe Credentials do
+
+    it 'provides access to the access key id' do
+      expect(Credentials.new('akid', 'secret').access_key_id).to eq('akid')
+    end
+
+    it 'provides access to the secret access key' do
+      expect(Credentials.new('akid', 'secret').secret_access_key).to eq('secret')
+    end
+
+    it 'provides access to the session tokey' do
+      creds = Credentials.new('akid', 'secret', 'token')
+      expect(creds.session_token).to eq('token')
+    end
+
+    it 'defaults the session token to nil' do
+      expect(Credentials.new('akid', 'secret').session_token).to be(nil)
+    end
+
+    describe '#set?' do
+
+      it 'returns true when the key and secret are both non nil values' do
+        expect(Credentials.new('akid', 'secret').set?).to be(true)
+      end
+
+      it 'returns false if the key is nil' do
+        expect(Credentials.new(nil, 'secret').set?).to be(false)
+      end
+
+      it 'returns false if the secret is nil' do
+        expect(Credentials.new('akid', nil).set?).to be(false)
+      end
+
+    end
+  end
+end

data/spec/aws/iam_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Aws
+  describe IAM do
+
+    it 'forces the endpoint to iam.amazonaws.com despite region' do
+      iam = IAM.new(region: 'us-west-2', credentials: dummy_credentials)
+      expect(iam.config.endpoint).to eq('iam.amazonaws.com')
+    end
+
+    it 'uses us-east-1 as the signing region' do
+      iam = IAM.new(region: 'us-west-2', credentials: dummy_credentials)
+      expect(iam.config.sigv4_region).to eq('us-east-1')
+    end
+
+  end
+end

data/spec/aws/json/builder_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+module Aws
+  module Json
+    describe Builder do
+
+      let(:rules) {{
+        'type' => 'input',
+        'serialized_name' => 'xml',
+        'members' => {},
+      }}
+
+      def json(params)
+        shape = Seahorse::Model::Shapes::Shape.from_hash(rules)
+        Builder.to_json(shape, params)
+      end
+
+      describe 'structures' do
+
+        it 'returns an empty xml doc when there are no params' do
+          expect(json({})).to eq('{}')
+        end
+
+        it 'omits params that are not in the rules' do
+          expect(json(abc: 'xyz')).to eq('{}')
+        end
+
+        it 'observes serialized name properties' do
+          rules['members'] = {
+            'name' => { 'type' => 'string', 'serialized_name' => 'FullName' }
+          }
+          expect(json(name: 'John Doe')).to eq('{"FullName":"John Doe"}')
+        end
+
+        it 'serializes nested structures' do
+          rules['members'] = {
+            'abc' => {
+              'type' => 'structure',
+              'members' => {
+                'mno' => { 'type' => 'string', 'serialized_name' => 'MNO' }
+              }
+            }
+          }
+          expect(json(abc: { mno: 'xyz' })).to eq('{"abc":{"MNO":"xyz"}}')
+        end
+
+      end
+
+      describe 'lists' do
+
+        it 'serializes lists' do
+          rules['members'] = {
+            'items' => {
+              'type' => 'list',
+              'members' => { 'type' => 'string' }
+            }
+          }
+          expect(json(items: %w(abc xyz))).to eq('{"items":["abc","xyz"]}')
+        end
+
+        it 'lists of complex shapes' do
+          rules['members'] = {
+            'abc' => {
+              'type' => 'list',
+              'members' => {
+                'type' => 'structure',
+                'members' => {
+                  'mno' => { 'type' => 'string', 'serialized_name' => 'MNO' }
+                }
+              }
+            }
+          }
+          expect(json(abc: [{mno:'xyz'}])).to eq('{"abc":[{"MNO":"xyz"}]}')
+        end
+
+      end
+
+      describe 'maps' do
+
+        it 'accepts an arbitrary hash of values' do
+          rules['members'] = {
+            'attrs' => {
+              'type' => 'map',
+              'keys' => { 'type' => 'string' },
+              'members' => { 'type' => 'string' }
+            }
+          }
+          params = { attrs: { 'Size' => 'large', 'Color' => 'red' } }
+          expect(json(params)).to eq('{"attrs":{"Size":"large","Color":"red"}}')
+        end
+
+        it 'supports complex hash values' do
+          rules['members'] = {
+            'people' => {
+              'type' => 'map',
+              'keys' => { 'type' => 'string' },
+              'members' => {
+                'type' => 'structure',
+                'members' => {
+                  'age' => { 'type' => 'integer', 'serialized_name' => 'AGE' }
+                }
+              }
+            }
+          }
+          params = { people: { 'John' => { age: 40 } } }
+          expect(json(params)).to eq('{"people":{"John":{"AGE":40}}}')
+        end
+
+      end
+
+      describe 'scalars' do
+
+        it 'serializes integers' do
+          rules['members'] = {
+            'count' => { 'type' => 'integer' }
+          }
+          expect(json(count: 123)).to eq('{"count":123}')
+        end
+
+        it 'serializes floats' do
+          rules['members'] = {
+            'price' => { 'type' => 'float' }
+          }
+          expect(json(price: 12.34)).to eq('{"price":12.34}')
+        end
+
+        it 'serializes booleans' do
+          rules['members'] = {
+            'hot' => { 'type' => 'boolean' },
+            'cold' => { 'type' => 'boolean' }
+          }
+          expect(json(hot:true, cold:false)).to eq('{"hot":true,"cold":false}')
+        end
+
+        it 'serializes iso8601 timestamps' do
+          now = Time.now
+          rules['members'] = {
+            'when' => { 'type' => 'iso8601_timestamp' }
+          }
+          expect(json(when:now)).to eq("{\"when\":\"#{now.utc.iso8601}\"}")
+        end
+
+        it 'can serializes timestamps as rfc8622 strings' do
+          now = Time.now
+          rules['members'] = {
+            'when' => {
+              'type' => 'rfc822_timestamp'
+            }
+          }
+          expect(json(when:now)).to eq("{\"when\":\"#{now.utc.rfc822}\"}")
+        end
+
+        it 'can serializes timestamps as unix timestamps' do
+          now = Time.now
+          rules['members'] = {
+            'when' => {
+              'type' => 'unix_timestamp',
+            }
+          }
+          expect(json(when:now)).to eq("{\"when\":#{now.to_i}}")
+        end
+
+        it 'raises an error when the timestamp format is not specified' do
+          now = Time.now
+          rules['members'] = {
+            'when' => {
+              'type' => 'timestamp',
+            }
+          }
+          expect { json(when:now) }.to raise_error(/invalid timestamp/)
+        end
+
+        it 'serializes blobs as base64 strings' do
+          rules['members'] = {
+            'data' => { 'type' => 'blob' }
+          }
+          expect(json(data:'hello')).to eq('{"data":"aGVsbG8="}')
+        end
+
+      end
+    end
+  end
+end