fog-aws 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22f2c524c85c86ab1668a6852c9c6c4f22545f45
-  data.tar.gz: 790fb6ee76f14d24586006db89bcd96a6f890e2e
+  metadata.gz: cdc745bb5b1444b37a5fd7c9ab29afe8aca65eec
+  data.tar.gz: 412dec3ceb7f2afc1232ba1115b8b09bdafd5b59
 SHA512:
-  metadata.gz: 09ac54ca56bc9da50d39ee43c762a4837daa9fb5a2c6617c75d11adb191a18ed863d339e141f257edec655e03475772065d0237e210776223723700257fa8df7
-  data.tar.gz: 2606b75208e8cf01a729b8ae2ab930619c2b1b021925ffa67d087657ced1a8ec714bb4a917095ea7ca3787eb8499c68e2480358fc0615c8e31a5fa945874762b
+  metadata.gz: b711a8189322c47c11ab9ff818302657fff403f14062169663f4914f7efc58a6aa706e826fdc21a3b2bac0cccc6974c7cb7f985323e0ceda3cfccb97efcd552c
+  data.tar.gz: 0254a3121c9fed3f257634c80f06939e6b6008adcddc8ac873d3a3c57ae70a8e0942a2f42a670cd9a88dfc2a1c56b77ade2ffa3a70d8f96ae8a6d4a61aa4fa38

data/lib/fog/aws/dns.rb

@@ -79,7 +79,7 @@ module Fog
         # :aws_secret_access_key in order to create a connection
         #
         # ==== Examples
-        #   dns = Fog::AWS::DNS.new(
+        #   dns = Fog::DNS::AWS.new(
         #     :aws_access_key_id => your_aws_access_key_id,
         #     :aws_secret_access_key => your_aws_secret_access_key
         #   )
@@ -141,6 +141,19 @@ module Fog
 
         def _request(params, &block)
           @connection.request(params, &block)
+        rescue Excon::Errors::HTTPStatusError => error
+          match = Fog::AWS::Errors.match_error(error)
+
+          if match.empty?
+            raise
+          else
+            case match[:code]
+            when 'NoSuchHostedZone', 'NoSuchChange' then
+              Fog::DNS::AWS::NotFound.slurp(error, match[:message])
+            else
+              Fog::DNS::AWS::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+            end
+          end
         end
 
         def signature(params)

data/lib/fog/aws/iam.rb

@@ -17,11 +17,15 @@ module Fog
       request_path 'fog/aws/requests/iam'
       request :add_user_to_group
       request :add_role_to_instance_profile
+      request :attach_group_policy
+      request :attach_role_policy
+      request :attach_user_policy
       request :create_access_key
       request :create_account_alias
       request :create_group
       request :create_instance_profile
       request :create_login_profile
+      request :create_policy
       request :create_role
       request :create_user
       request :delete_access_key
@@ -31,12 +35,16 @@ module Fog
       request :delete_group_policy
       request :delete_instance_profile
       request :delete_login_profile
+      request :delete_policy
       request :delete_role
       request :delete_role_policy
       request :delete_server_certificate
       request :delete_signing_certificate
       request :delete_user
       request :delete_user_policy
+      request :detach_group_policy
+      request :detach_role_policy
+      request :detach_user_policy
       request :get_account_summary
       request :get_account_password_policy
       request :get_group
@@ -56,6 +64,7 @@ module Fog
       request :list_instance_profiles
       request :list_instance_profiles_for_role
       request :list_mfa_devices
+      request :list_policies
       request :list_roles
       request :list_role_policies
       request :list_server_certificates

data/lib/fog/aws/models/compute/flavors.rb

@@ -155,6 +155,56 @@ module Fog
           :ebs_optimized_available => false,
           :instance_store_volumes  => 2
         },
+        {
+          :id                      => 'c4.large',
+          :name                    => 'C4 Large',
+          :bits                    => 64,
+          :cores                   => 7,
+          :disk                    => 32,
+          :ram                     => 3750,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'c4.xlarge',
+          :name                    => 'C4 Extra Large',
+          :bits                    => 64,
+          :cores                   => 14,
+          :disk                    => 80,
+          :ram                     => 7168,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'c4.2xlarge',
+          :name                    => 'C4 Double Extra Large',
+          :bits                    => 64,
+          :cores                   => 28,
+          :disk                    => 160,
+          :ram                     => 15360,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'c4.4xlarge',
+          :name                    => 'C4 Quadruple Extra Large',
+          :bits                    => 64,
+          :cores                   => 55,
+          :disk                    => 320,
+          :ram                     => 30720,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'c4.8xlarge',
+          :name                    => 'C4 Eight Extra Large',
+          :bits                    => 64,
+          :cores                   => 122,
+          :disk                    => 640,
+          :ram                     => 61440,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 2
+        },
         {
           :id                      => 'g2.2xlarge',
           :name                    => 'GPU Double Extra Large',

data/lib/fog/aws/models/dns/records.rb

@@ -81,32 +81,26 @@ module Fog
           record_type = record_type.upcase unless record_type.nil?
 
           options = {
-              :max_items => 1,
-              :name => record_name,
-              :type => record_type,
+              :max_items  => 1,
+              :name       => record_name,
+              :type       => record_type,
               :identifier => record_identifier
           }
           options.delete_if {|key, value| value.nil?}
 
           data = service.list_resource_record_sets(zone.id, options).body
-          # Get first record
-          data = data['ResourceRecordSets'].shift
-
-          if data
-            record = new(data)
-            # make sure everything matches
-            if record.name == record_name
-              if (!record_type.nil? && record.type != record_type) ||
-                  (!record_identifier.nil? && record.set_identifier != record_identifier)
-                nil
-              else
-                record
-              end
+
+          # look for an exact match in the records
+          (data['ResourceRecordSets'] || []).map do |record_data|
+            record = new(record_data)
+
+            if (record.name == record_name) &&
+                (record_type.nil? || (record.type == record_type)) &&
+                (record_identifier.nil? || (record.set_identifier == record_identifier))
+              record
             end
-          else
-            nil
-          end
-        rescue Excon::Errors::NotFound
+          end.compact.first
+        rescue Fog::DNS::AWS::NotFound
           nil
         end
 

data/lib/fog/aws/models/dns/zones.rb

@@ -20,7 +20,7 @@ module Fog
         def get(zone_id)
           data = service.get_hosted_zone(zone_id).body
           new(data)
-        rescue Excon::Errors::NotFound
+        rescue Fog::DNS::AWS::NotFound
           nil
         end
       end

data/lib/fog/aws/models/storage/file.rb

@@ -23,6 +23,7 @@ module Fog
         attribute :owner,               :aliases => 'Owner'
         attribute :storage_class,       :aliases => ['x-amz-storage-class', 'StorageClass']
         attribute :encryption,          :aliases => 'x-amz-server-side-encryption'
+        attribute :encryption_key,      :aliases => 'x-amz-server-side-encryption-customer-key'
         attribute :version,             :aliases => 'x-amz-version-id'
 
         # @note Chunk size to use for multipart uploads.
@@ -199,7 +200,7 @@ module Fog
           options['Expires'] = expires if expires
           options.merge!(metadata)
           options['x-amz-storage-class'] = storage_class if storage_class
-          options['x-amz-server-side-encryption'] = encryption if encryption
+          options.merge!(encryption_headers)
 
           if multipart_chunk_size && body.respond_to?(:read)
             data = multipart_save(options)
@@ -261,8 +262,7 @@ module Fog
             body.rewind  rescue nil
           end
           while (chunk = body.read(multipart_chunk_size)) do
-            md5 = Base64.encode64(Digest::MD5.digest(chunk)).strip
-            part_upload = service.upload_part(directory.key, key, upload_id, part_tags.size + 1, chunk, 'Content-MD5' => md5 )
+            part_upload = service.upload_part(directory.key, key, upload_id, part_tags.size + 1, chunk, part_headers(chunk, options))
             part_tags << part_upload.headers["ETag"]
           end
 
@@ -274,6 +274,31 @@ module Fog
           # Complete the upload
           service.complete_multipart_upload(directory.key, key, upload_id, part_tags)
         end
+
+        def encryption_headers
+          if encryption && encryption_key
+            encryption_customer_key_headers
+          elsif encryption
+            { 'x-amz-server-side-encryption' => encryption }
+          else
+            {}
+          end
+        end
+
+        def part_headers(chunk, options)
+          md5 = Base64.encode64(Digest::MD5.digest(chunk)).strip
+          encryption_keys = encryption_customer_key_headers.keys
+          encryption_headers = options.select { |key| encryption_keys.include?(key) }
+          { 'Content-MD5' => md5 }.merge(encryption_headers)
+        end
+
+        def encryption_customer_key_headers
+          {
+            'x-amz-server-side-encryption-customer-algorithm' => encryption,
+            'x-amz-server-side-encryption-customer-key' => Base64.encode64(encryption_key.to_s).chomp!,
+            'x-amz-server-side-encryption-customer-key-md5' => Base64.encode64(Digest::MD5.digest(encryption_key.to_s)).chomp!
+          }
+        end
       end
     end
   end

data/lib/fog/aws/models/storage/files.rb

@@ -92,6 +92,11 @@ module Fog
           service.get_object_https_url(directory.key, key, expires, options)
         end
 
+        def head_url(key, expires, options = {})
+          requires :directory
+          service.head_object_url(directory.key, key, expires, options)
+        end
+
         def head(key, options = {})
           requires :directory
           data = service.head_object(directory.key, key, options)

data/lib/fog/aws/parsers/iam/list_managed_policies.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Parsers
+    module AWS
+      module IAM
+        require 'fog/aws/parsers/iam/policy_parser'
+        class ListManagedPolicies < Fog::Parsers::AWS::IAM::PolicyParser
+          def reset
+            super
+            @response = { 'Policies' => [] , 'Marker' => '', 'IsTruncated' => false}
+          end
+
+          def finished_policy(policy)
+            @response['Policies'] << policy
+          end
+
+          def end_element(name)
+            case name
+            when 'RequestId', 'Marker'
+              @response[name] = value
+            when 'IsTruncated'
+              @response[name] = (value == 'true')
+            end
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/iam/policy_parser.rb

@@ -0,0 +1,57 @@
+module Fog
+  module Parsers
+    module AWS
+      module IAM
+        class PolicyParser < Fog::Parsers::Base
+          def reset
+            @policy = fresh_policy
+            @stack = []
+          end
+
+          def start_element(name,attrs = [])
+            case name
+            when 'Policies'
+              @stack << name
+            when 'Policy'
+              @role =fresh_policy
+            when 'member'
+              if @stack.last == 'Policies'
+                @role = fresh_policy
+              end
+            end
+            super
+          end
+
+          def fresh_policy
+            {'AttachmentCount' => 0, 'Description' => ''}
+          end
+
+          def end_element(name)
+            case name
+            when 'Arn', 'DefaultVersionId', 'Description', 'Path', 'PolicyName', 'PolicyId'
+              @policy[name] = value
+            when 'CreateDate', 'UpdateDate'
+              @policy[name] = Time.parse(value)
+            when 'IsAttachable'
+              @policy[name] = (value == 'true')
+            when 'AttachmentCount'
+              @policy[name] = value.to_i
+            when 'Policy'
+              finished_policy(@policy)
+              @policy = nil
+            when 'Policies'
+              if @stack.last == 'Policies'
+                @stack.pop
+              end
+            when 'member'
+              if @stack.last == 'Policies'
+                finished_policy(@policy)
+                @policy = nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/iam/single_policy.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Parsers
+    module AWS
+      module IAM
+        require 'fog/aws/parsers/iam/policy_parser'
+        class SinglePolicy < Fog::Parsers::AWS::IAM::PolicyParser
+          def reset
+            super
+            @response = { 'Policy' => {} }
+          end
+
+          def finished_policy(policy)
+            @response['Policy'] = policy
+          end
+
+          def end_element(name)
+            case name
+            when 'RequestId'
+              @response[name] = value
+            end
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/rds.rb

@@ -126,11 +126,13 @@ module Fog
 
         def initialize(options={})
           @use_iam_profile = options[:use_iam_profile]
-          @region = options[:region] || 'us-east-1'
+          @region          = options[:region] || 'us-east-1'
 
           unless ['ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2', 'eu-central-1', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'sa-east-1'].include?(@region)
             raise ArgumentError, "Unknown region: #{@region.inspect}"
           end
+
+          setup_credentials(options)
         end
 
         def data

data/lib/fog/aws/requests/compute/authorize_security_group_ingress.rb

@@ -87,43 +87,39 @@ module Fog
           end
 
           response = Excon::Response.new
-          group = self.data[:security_groups][group_name]
+          group = self.data[:security_groups][group_name] || raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist"))
 
-          if group
-            verify_permission_options(options, group['vpcId'] != nil)
+          verify_permission_options(options, group['vpcId'] != nil)
 
-            normalized_permissions = normalize_permissions(options)
+          normalized_permissions = normalize_permissions(options)
 
-            normalized_permissions.each do |permission|
-              if matching_group_permission = find_matching_permission(group, permission)
-                if permission['groups'].any? {|pg| matching_group_permission['groups'].include?(pg) }
-                  raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
-                end
-
-                if permission['ipRanges'].any? {|pr| matching_group_permission['ipRanges'].include?(pr) }
-                  raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
-                end
+          normalized_permissions.each do |permission|
+            if matching_group_permission = find_matching_permission(group, permission)
+              if permission['groups'].any? {|pg| matching_group_permission['groups'].include?(pg) }
+                raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
               end
-            end
 
-            normalized_permissions.each do |permission|
-              if matching_group_permission = find_matching_permission(group, permission)
-                matching_group_permission['groups'] += permission['groups']
-                matching_group_permission['ipRanges'] += permission['ipRanges']
-              else
-                group['ipPermissions'] << permission
+              if permission['ipRanges'].any? {|pr| matching_group_permission['ipRanges'].include?(pr) }
+                raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
               end
             end
+          end
 
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist")
+          normalized_permissions.each do |permission|
+            if matching_group_permission = find_matching_permission(group, permission)
+              matching_group_permission['groups'] += permission['groups']
+              matching_group_permission['ipRanges'] += permission['ipRanges']
+            else
+              group['ipPermissions'] << permission
+            end
           end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
         end
 
         private
@@ -158,58 +154,67 @@ module Fog
             ['tcp', 'udp'].each do |protocol|
               normalized_permissions << {
                 'ipProtocol' => protocol,
-                'fromPort' => 1,
-                'toPort' => 65535,
-                'groups' => [{'groupName' => options['SourceSecurityGroupName'], 'userId' => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id], 'groupId' => source_group_id }],
-                'ipRanges' => []
+                'fromPort'   => 1,
+                'toPort'     => 65535,
+                'groups'     => [{
+                  'groupName' => options['SourceSecurityGroupName'],
+                  'userId'    => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id],
+                  'groupId'   => source_group_id
+                }],
+                'ipRanges'   => []
               }
             end
             normalized_permissions << {
               'ipProtocol' => 'icmp',
-              'fromPort' => -1,
-              'toPort' => -1,
-              'groups' => [{'groupName' => options['SourceSecurityGroupName'], 'userId' => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id], 'groupId' => source_group_id }],
+              'fromPort'   => -1,
+              'toPort'     => -1,
+              'groups'     => [{
+                'groupName' => options['SourceSecurityGroupName'],
+                'userId'    => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id],
+                'groupId'   => source_group_id
+              }],
               'ipRanges' => []
             }
           elsif options['CidrIp']
             normalized_permissions << {
               'ipProtocol' => options['IpProtocol'],
-              'fromPort' => Integer(options['FromPort']),
-              'toPort' => Integer(options['ToPort']),
-              'groups' => [],
-              'ipRanges' => [{'cidrIp' => options['CidrIp']}]
+              'fromPort'   => Integer(options['FromPort']),
+              'toPort'     => Integer(options['ToPort']),
+              'groups'     => [],
+              'ipRanges'   => [{'cidrIp' => options['CidrIp']}]
             }
           elsif options['IpPermissions']
             options['IpPermissions'].each do |permission|
+
+              groups = (permission['Groups'] || []).map do |authorized_group|
+                security_group = if group_name = authorized_group['GroupName']
+                                   self.data[:security_groups][group_name]
+                                 elsif group_id = authorized_group['GroupId']
+                                   self.data[:security_groups].values.find { |sg| sg['groupId'] == group_id }
+                                 end ||
+                                 raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name || group_id}' does not exist"))
+
+                                 {
+                                   'groupName' => authorized_group['GroupName'] || security_group["groupName"],
+                                   'userId'    => authorized_group['UserId']    || self.data[:owner_id],
+                                   'groupId'   => authorized_group["GroupId"]   || security_group['groupId']
+                                 }
+                  end
+
+
               if ['tcp', 'udp', 'icmp'].include?(permission['IpProtocol'])
                 normalized_permissions << {
                   'ipProtocol' => permission['IpProtocol'],
-                  'fromPort' => Integer(permission['FromPort']),
-                  'toPort' => Integer(permission['ToPort']),
-                  'groups' => (permission['Groups'] || []).map do |authorized_group|
-                    security_group = if group_name = authorized_group['GroupName']
-                                       self.data[:security_groups][group_name] || {}
-                                     elsif group_id = authorized_group['GroupId']
-                                       self.data[:security_groups].values.find { |sg| sg['groupId'] == group_id } || {}
-                                     end
-
-                    {'groupName' => authorized_group['GroupName'] || security_group["groupName"], 'userId' => authorized_group['UserId'] || self.data[:owner_id], 'groupId' => authorized_group["GroupId"] || security_group['groupId']}
-                  end,
+                  'fromPort'   => Integer(permission['FromPort']),
+                  'toPort'     => Integer(permission['ToPort']),
+                  'groups'     => groups,
                   'ipRanges' => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
                 }
               else
                 normalized_permissions << {
                   'ipProtocol' => permission['IpProtocol'],
-                  'groups' => (permission['Groups'] || []).map do |authorized_group|
-                    security_group = if group_name = authorized_group['GroupName']
-                                       self.data[:security_groups][group_name] || {}
-                                     elsif group_id = authorized_group['GroupId']
-                                       self.data[:security_groups].values.find { |sg| sg['groupId'] == group_id } || {}
-                                     end
-
-                    {'groupName' => authorized_group['GroupName'] || security_group["groupName"], 'userId' => authorized_group['UserId'] || self.data[:owner_id], 'groupId' => authorized_group["GroupId"] || security_group['groupId']}
-                  end,
-                  'ipRanges' => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
+                  'groups'     => groups,
+                  'ipRanges'   => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
                 }
               end
             end
@@ -221,8 +226,8 @@ module Fog
         def find_matching_permission(group, permission)
           group['ipPermissions'].find {|group_permission|
             permission['ipProtocol'] == group_permission['ipProtocol'] &&
-            permission['fromPort'] == group_permission['fromPort'] &&
-            permission['toPort'] == group_permission['toPort'] }
+              permission['fromPort'] == group_permission['fromPort'] &&
+              permission['toPort'] == group_permission['toPort'] }
         end
       end
     end