fog-aws 0.1.2 → 0.2.0

data/lib/fog/aws/requests/dns/change_resource_record_sets.rb

@@ -151,6 +151,19 @@ module Fog
       end
 
       class Mock
+        SET_PREFIX = 'SET_'
+        def record_exist?(zone,change,change_name)
+          return false if zone[:records][change[:type]].nil?
+          current_records = zone[:records][change[:type]][change_name]
+          return false if current_records.nil?
+
+          if !change[:set_identifier].empty?
+            !current_records[change[:SetIdentifier]].nil?
+          else
+            !current_records.empty?
+          end
+        end
+
         def change_resource_record_sets(zone_id, change_batch, options = {})
           response = Excon::Response.new
           errors   = []
@@ -171,9 +184,9 @@ module Fog
                   zone[:records][change[:type]] = {}
                 end
 
-                if zone[:records][change[:type]][change_name].nil?
+                if !record_exist?(zone, change, change_name)
                   # raise change.to_s if change[:resource_records].nil?
-                  zone[:records][change[:type]][change_name] =
+                  new_record =
                   if change[:alias_target]
                     record = {
                       :alias_target => change[:alias_target]
@@ -183,17 +196,35 @@ module Fog
                       :ttl => change[:ttl].to_s,
                     }
                   end
-                  zone[:records][change[:type]][change_name] = {
+
+                  new_record = {
                     :change_id        => change_id,
                     :resource_records => change[:resource_records] || [],
                     :name             => change_name,
-                    :type             => change[:type]
+                    :type             => change[:type],
+                    :set_identifier   => change[:set_identifier],
+                    :weight           => change[:weight]
                   }.merge(record)
+
+                  if change[:set_identifier].nil?
+                    zone[:records][change[:type]][change_name] = new_record
+                  else
+                    zone[:records][change[:type]][change_name] = {} if zone[:records][change[:type]][change_name].nil?
+                    zone[:records][change[:type]][change_name][SET_PREFIX + change[:set_identifier]] = new_record
+                  end
                 else
                   errors << "Tried to create resource record set #{change[:name]}. type #{change[:type]}, but it already exists"
                 end
               when "DELETE"
-                if zone[:records][change[:type]].nil? || zone[:records][change[:type]].delete(change_name).nil?
+                action_performed = false
+                if !zone[:records][change[:type]].nil? && !zone[:records][change[:type]][change_name].nil? && !change[:set_identifier].nil?
+                  action_performed = true unless zone[:records][change[:type]][change_name].delete(SET_PREFIX + change[:set_identifier]).nil?
+                  zone[:records][change[:type]].delete(change_name) if zone[:records][change[:type]][change_name].empty?
+                elsif !zone[:records][change[:type]].nil?
+                  action_performed = true unless zone[:records][change[:type]].delete(change_name).nil?
+                end
+
+                if !action_performed
                   errors << "Tried to delete resource record set #{change[:name]}. type #{change[:type]}, but it was not found"
                 end
               end

data/lib/fog/aws/requests/dns/list_resource_record_sets.rb

@@ -59,6 +59,22 @@ module Fog
       end
 
       class Mock
+        def list_all_records(record, zone, name)
+          [].tap do |tmp_records|
+            tmp_records.push(record) if !record[:name].nil? && ( name.nil? || record[:name].gsub(zone[:name],"") >= name)
+            record.each do |key,subr|
+              if subr.is_a?(Hash) && key.is_a?(String) &&
+                key.start_with?(Fog::DNS::AWS::Mock::SET_PREFIX)
+                if name.nil?
+                  tmp_records.append(subr)
+                else
+                  tmp_records.append(subr) if !subr[:name].nil? && subr[:name].gsub(zone[:name],"") >= name
+                end
+              end
+            end
+          end
+        end
+
         def list_resource_record_sets(zone_id, options = {})
           maxitems = [options[:max_items]||100,100].min
 
@@ -76,13 +92,23 @@ module Fog
 
           records ||= []
 
-          # sort for pagination
-          records.sort! { |a,b| a[:name].gsub(zone[:name],"") <=> b[:name].gsub(zone[:name],"") }
-
+          tmp_records = []
           if options[:name]
             name = options[:name].gsub(zone[:name],"")
-            records = records.select{|r| r[:name].gsub(zone[:name],"") >= name }
+
+            records.each do |r|
+              tmp_records += list_all_records(r, zone, name)
+            end
+          else
+            records.each do |r|
+              tmp_records += list_all_records(r, zone, nil)
+            end
           end
+          records = tmp_records
+
+          # sort for pagination
+          records.sort! { |a,b| a[:name].gsub(zone[:name],"") <=> b[:name].gsub(zone[:name],"") }
+
 
           next_record  = records[maxitems]
           records      = records[0, maxitems]
@@ -106,7 +132,9 @@ module Fog
               {
                 'ResourceRecords' => r[:resource_records],
                 'Name' => r[:name],
-                'Type' => r[:type]
+                'Type' => r[:type],
+                'SetIdentifier' => r[:set_identifier],
+                'Weight' => r[:weight]
               }.merge(record)
             end,
             'MaxItems' => maxitems,

data/lib/fog/aws/requests/elb/create_load_balancer.rb

@@ -74,9 +74,22 @@ module Fog
           dns_name = Fog::AWS::ELB::Mock.dns_name(lb_name, @region)
 
           availability_zones = [*availability_zones].compact
-          region = availability_zones.empty? ? "us-east-1" : availability_zones.first.gsub(/[a-z]$/, '')
-          supported_platforms = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"]
           subnet_ids = options[:subnet_ids] || []
+          region = if availability_zones.any?
+                     availability_zones.first.gsub(/[a-z]$/, '')
+                   elsif subnet_ids.any?
+                     # using Hash here for Rubt 1.8.7 support.
+                     Hash[
+                       Fog::Compute::AWS::Mock.data.select do |_, region_data|
+                         region_data[@aws_access_key_id][:subnets].any? do |region_subnets|
+                           subnet_ids.include? region_subnets['subnetId']
+                         end
+                       end
+                     ].keys[0]
+                   else
+                     'us-east-1'
+                   end
+          supported_platforms = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"]
           subnets = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:subnets].select {|e| subnet_ids.include?(e["subnetId"]) }
 
           # http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/default-vpc.html

data/lib/fog/aws/requests/iam/create_role.rb

@@ -42,11 +42,11 @@ module Fog
         #
         def create_role(role_name, assume_role_policy_document, path = '/')
           request(
-            'Action'    => 'CreateRole',
-            'RoleName'  => role_name,
-            'AssumeRolePolicyDocument'      => assume_role_policy_document,
-            'Path'      => path,
-            :parser     => Fog::Parsers::AWS::IAM::SingleRole.new
+            'Action'                   => 'CreateRole',
+            'RoleName'                 => role_name,
+            'AssumeRolePolicyDocument' => assume_role_policy_document,
+            'Path'                     => path,
+            :parser                    => Fog::Parsers::AWS::IAM::SingleRole.new
           )
         end
       end

data/lib/fog/aws/requests/kms/create_key.rb

@@ -0,0 +1,62 @@
+module Fog
+  module AWS
+    class KMS
+      class Real
+        DEFAULT_KEY_POLICY = <<-JSON
+{
+  "Version": "2012-10-17",
+  "Id": "key-default-1",
+  "Statement": [
+    {
+      "Sid": "Enable IAM User Permissions",
+      "Effect": "Allow",
+      "Principal": {
+        "AWS": "arn:aws:iam::915445820265:root"
+      },
+      "Action": "kms:*",
+      "Resource": "*"
+    }
+  ]
+}
+        JSON
+
+        require 'fog/aws/parsers/kms/describe_key'
+
+        def create_key(policy = nil, description = nil, usage = "ENCRYPT_DECRYPT")
+          request(
+            'Action'      => 'CreateKey',
+            'Description' => description,
+            'KeyUsage'    => usage,
+            'Policy'      => policy,
+            :parser       => Fog::Parsers::AWS::KMS::DescribeKey.new
+          )
+        end
+      end
+
+      class Mock
+        def create_key(policy = nil, description = nil, usage = "ENCRYPT_DECRYPT")
+          response = Excon::Response.new
+          key_id   = UUID.uuid
+          key_arn  = Fog::AWS::Mock.arn("kms", self.account_id, "key/#{key_id}", @region)
+
+          key = {
+            "KeyUsage"     => usage,
+            "AWSAccountId" => self.account_id,
+            "KeyId"        => key_id,
+            "Description"  => description,
+            "CreationDate" => Time.now,
+            "Arn"          => key_arn,
+            "Enabled"      => true,
+          }
+
+          # @todo use default policy
+
+          self.data[:keys][key_id] = key
+
+          response.body = { "KeyMetadata" => key }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/kms/describe_key.rb

@@ -0,0 +1,27 @@
+module Fog
+  module AWS
+    class KMS
+      class Real
+        require 'fog/aws/parsers/kms/describe_key'
+
+        def describe_key(identifier)
+          request(
+            'Action' => 'DescribeKey',
+            'KeyId'  => identifier,
+            :parser  => Fog::Parsers::AWS::KMS::DescribeKey.new
+          )
+        end
+      end
+
+      class Mock
+        def describe_key(identifier)
+          response = Excon::Response.new
+          key = self.data[:keys][identifier]
+
+          response.body = { "KeyMetadata" => key }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/kms/list_keys.rb

@@ -0,0 +1,82 @@
+module Fog
+  module AWS
+    class KMS
+      class Real
+
+        require 'fog/aws/parsers/kms/list_keys'
+
+        def list_keys(options={})
+          params = {}
+
+          if options[:marker]
+            params['Marker'] = options[:marker]
+          end
+
+          if options[:limit]
+            params['Limit'] = options[:limit]
+          end
+
+          request({
+            'Action' => 'ListKeys',
+            :parser  => Fog::Parsers::AWS::KMS::ListKeys.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def list_keys(options={})
+          limit  = options[:limit]
+          marker = options[:marker]
+
+          if limit
+            if limit > 1_000
+              raise Fog::AWS::KMS::Error.new(
+                "ValidationError => 1 validation error detected: Value '#{limit}' at 'limit' failed to satisfy constraint: Member must have value less than or equal to 1000"
+              )
+            elsif limit <  1
+              raise Fog::AWS::KMS::Error.new(
+                "ValidationError => 1 validation error detected: Value '#{limit}' at 'limit' failed to satisfy constraint: Member must have value greater than or equal to 1"
+              )
+            end
+          end
+
+          key_set = if marker
+                      self.data[:markers][marker] || []
+                    else
+                      self.data[:keys].inject([]) { |r,(k,v)|
+                        r << { "KeyId" => k, "KeyArn" => v["Arn"] }
+                      }
+                    end
+
+          keys = if limit
+                   key_set.slice!(0, limit)
+                 else
+                   key_set
+                 end
+
+          truncated = keys.size < key_set.size
+
+          marker = truncated && "metadata/l/#{account_id}/#{UUID.uuid}"
+
+          response = Excon::Response.new
+
+          body = {
+            'Keys'      => keys,
+            'Truncated' => truncated,
+            'RequestId' => Fog::AWS::Mock.request_id
+          }
+
+          if marker
+            self.data[:markers][marker] = key_set
+            body.merge!('Marker' => marker)
+          end
+
+          response.body = body
+          response.status = 200
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/create_db_instance.rb

@@ -25,7 +25,7 @@ module Fog
         # @param PreferredBackupWindow [String] The daily time range during which automated backups are created if automated backups are enabled
         # @param PreferredMaintenanceWindow [String] The weekly time range (in UTC) during which system maintenance can occur, which may result in an outage
         # @param DBSubnetGroupName [String] The name, if any, of the VPC subnet for this RDS instance
-        # @param PubliclyAcccesible [Boolean] Whether an RDS instance inside of the VPC subnet should have a public-facing endpoint
+        # @param PubliclyAccessible [Boolean] Whether an RDS instance inside of the VPC subnet should have a public-facing endpoint
         # @param VpcSecurityGroups [Array] A list of VPC Security Groups to authorize on this DB instance
         # @param StorageType [string] Specifies storage type to be associated with the DB Instance.  Valid values: standard | gp2 | io1
         #
@@ -43,9 +43,9 @@ module Fog
           end
 
           request({
-            'Action'  => 'CreateDBInstance',
+            'Action'               => 'CreateDBInstance',
             'DBInstanceIdentifier' => db_name,
-            :parser   => Fog::Parsers::AWS::RDS::CreateDBInstance.new,
+            :parser                => Fog::Parsers::AWS::RDS::CreateDBInstance.new,
           }.merge(options))
         end
       end
@@ -78,41 +78,36 @@ module Fog
             end
           end
 
-          data =
-              {
-                 "DBInstanceIdentifier"=> db_name,
-                 "DBName" => options["DBName"],
-                 "InstanceCreateTime" => nil,
-                 "AutoMinorVersionUpgrade"=>true,
-                 "Endpoint"=>{},
-                 "ReadReplicaDBInstanceIdentifiers"=>[],
-                 "PreferredMaintenanceWindow"=>"mon:04:30-mon:05:00",
-                 "Engine"=> options["Engine"],
-                 "EngineVersion"=> options["EngineVersion"] || "5.5.12",
-                 "PendingModifiedValues"=>{"MasterUserPassword"=>"****"}, # This clears when is available
-                 "MultiAZ"=> !!options['MultiAZ'],
-                 "MasterUsername"=> options["MasterUsername"],
-                 "DBInstanceClass"=> options["DBInstanceClass"],
-                 "DBInstanceStatus"=>"creating",
-                 "BackupRetentionPeriod"=> options["BackupRetentionPeriod"] || 1,
-                 "AllocatedStorage"=> options["AllocatedStorage"],
-                 "Iops" => options["Iops"],
-                 "DBParameterGroups"=> # I think groups should be in the self.data method
-                          [{"DBParameterGroupName"=>"default.mysql5.5",
-                            "ParameterApplyStatus"=>"in-sync"}],
-                 "DBSecurityGroups"=>
-                          [{"Status"=>"active",
-                            "DBSecurityGroupName"=>"default"}],
-                 "LicenseModel"=>"general-public-license",
-                 "PreferredBackupWindow"=>"08:00-08:30",
-#                 "ReadReplicaSourceDBInstanceIdentifier" => nil,
-#                 "LatestRestorableTime" => nil,
-                 "AvailabilityZone" => options["AvailabilityZone"],
-                 "DBSubnetGroupName" => options["DBSubnetGroupName"],
-                 "PubliclyAccessible" => options["PubliclyAccessible"],
-                 "VpcSecurityGroups" => options["VpcSecurityGroups"],
-                 "StorageType" => options["StorageType"],
-             }
+          data = {
+            "AllocatedStorage"                 => options["AllocatedStorage"],
+            "AutoMinorVersionUpgrade"          => options["AutoMinorVersionUpgrade"].nil? ? true : options["AutoMinorVersionUpgrade"],
+            "AvailabilityZone"                 => options["AvailabilityZone"],
+            "BackupRetentionPeriod"            => options["BackupRetentionPeriod"] || 1,
+            "CACertificateIdentifier"          => "rds-ca-2015",
+            "DBInstanceClass"                  => options["DBInstanceClass"],
+            "DBInstanceIdentifier"             => db_name,
+            "DBInstanceStatus"                 =>"creating",
+            "DBName"                           => options["DBName"],
+            "DBParameterGroups"                => [{ "DBParameterGroupName" => "default.mysql5.5", "ParameterApplyStatus" => "in-sync" }],
+            "DBSecurityGroups"                 => [{ "Status" => "active", "DBSecurityGroupName" => "default" }],
+            "DBSubnetGroupName"                => options["DBSubnetGroupName"],
+            "Endpoint"                         =>{},
+            "Engine"                           => options["Engine"],
+            "EngineVersion"                    => options["EngineVersion"] || "5.5.12",
+            "InstanceCreateTime"               => nil,
+            "Iops"                             => options["Iops"],
+            "LicenseModel"                     => "general-public-license",
+            "MasterUsername"                   => options["MasterUsername"],
+            "MultiAZ"                          => !!options['MultiAZ'],
+            "PendingModifiedValues"            => { "MasterUserPassword" => "****" }, # This clears when is available
+            "PreferredBackupWindow"            => options["PreferredBackupWindow"] || "08:00-08:30",
+            "PreferredMaintenanceWindow"       => options["PreferredMaintenanceWindow"] || "mon:04:30-mon:05:00",
+            "PubliclyAccessible"               => !!options["PubliclyAccessible"],
+            "ReadReplicaDBInstanceIdentifiers" => [],
+            "StorageEncrypted"                 => false,
+            "StorageType"                      => options["StorageType"] || "standard",
+            "VpcSecurityGroups"                => options["VpcSecurityGroups"],
+          }
 
           self.data[:servers][db_name] = data
           response.body = {

data/lib/fog/aws/requests/rds/create_db_instance_read_replica.rb

@@ -34,8 +34,10 @@ module Fog
           source = self.data[:servers][source_identifier]
           data = {
             'AllocatedStorage'                      => source['AllocatedStorage'],
-            'AutoMinorVersionUpgrade'               => options.key?('AutoMinorVersionUpgrade') ? options['AutoMinorVersionUpgrade'] : true,
+            'AutoMinorVersionUpgrade'               => options.key?('AutoMinorVersionUpgrade') ? options['AutoMinorVersionUpgrade'] : source['AutoMinorVersionUpgrade'],
             'AvailabilityZone'                      => options['AvailabilityZone'],
+            'BackupRetentionPeriod'                 => options['BackupRetentionPeriod'] || 0,
+            'CACertificateIdentifier'               => "rds-ca-2015",
             'DBInstanceClass'                       => options['DBInstanceClass'] || 'db.m1.small',
             'DBInstanceIdentifier'                  => instance_identifier,
             'DBInstanceStatus'                      => 'creating',
@@ -54,8 +56,11 @@ module Fog
             'PendingModifiedValues'                 => {},
             'PreferredBackupWindow'                 => '08:00-08:30',
             'PreferredMaintenanceWindow'            => "mon:04:30-mon:05:00",
+            'PubliclyAccessible'                    => !!options["PubliclyAccessible"],
             'ReadReplicaDBInstanceIdentifiers'      => [],
-            'ReadReplicaSourceDBInstanceIdentifier' => source_identifier
+            'ReadReplicaSourceDBInstanceIdentifier' => source_identifier,
+            'StorageType'                           => options['StorageType'] || 'standard',
+            'StorageEncrypted'                      => false,
           }
           self.data[:servers][instance_identifier] = data
           self.data[:servers][source_identifier]['ReadReplicaDBInstanceIdentifiers'] << instance_identifier