fog 1.19.0 → 1.20.0

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

@@ -47,6 +47,10 @@ module Fog
         # *   'tagSet'<~Array>:             - Tags assigned to the resource.
         # *     'key'<~String>              - Tag's key
         # *     'value'<~String>            - Tag's value
+        # *   'privateIpAddresses' <~Array>:
+        # *     'privateIpAddress'<~String> - One of the additional private ip address
+        # *     'privateDnsName'<~String>   - The private DNS associate to the ip address
+        # *     'primay'<~String>           - Whether main ip associate with NIC true of false
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2012-03-01/APIReference/index.html?ApiReference-query-DescribeNetworkInterfaces.html]
         def describe_network_interfaces(filters = {})

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

@@ -37,9 +37,10 @@ module Fog
           response.status = 200
           if address = self.data[:addresses][public_ip]
             instance_id = address['instanceId']
-            instance = self.data[:instances][instance_id]
-            instance['ipAddress']         = instance['originalIpAddress']
-            instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
+            if instance = self.data[:instances][instance_id]
+              instance['ipAddress']         = instance['originalIpAddress']
+              instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
+            end
             address['instanceId'] = nil
             response.status = 200
             response.body = {

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

@@ -0,0 +1,66 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/replace_network_acl_association'
+
+        # Replace the network ACL for a subnet with a 
+        #
+        # ==== Parameters
+        # * association_id<~String> - The ID of the current association between the original network ACL and the subnet
+        # * network_acl_id<~String> - The ID of the network ACL
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'return'<~Boolean> - Returns true if the request succeeds.
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-ReplaceNetworkAclAssociation.html]
+        def replace_network_acl_association(association_id, network_acl_id)
+          request({
+            'Action'        => 'ReplaceNetworkAclAssociation',
+            'AssociationId' => association_id,
+            'NetworkAclId'  => network_acl_id,
+            :parser         => Fog::Parsers::Compute::AWS::ReplaceNetworkAclAssociation.new
+          })
+        end
+      end
+
+      class Mock
+        def replace_network_acl_association(association_id, network_acl_id)
+          response = Excon::Response.new
+          if self.data[:network_acls][network_acl_id]
+            # find the old assoc
+            old_nacl = self.data[:network_acls].values.detect do |n|
+              n['associationSet'].detect { |assoc| assoc['networkAclAssociationId'] == association_id }
+            end
+
+            unless old_nacl
+              raise Fog::Compute::AWS::Error.new("Invalid association_id #{association_id}")
+            end
+
+            subnet_id = old_nacl['associationSet'].detect { |assoc| assoc['networkAclAssociationId'] == association_id }['subnetId']
+            old_nacl['associationSet'].delete_if { |assoc| assoc['networkAclAssociationId'] == association_id }
+
+            id = Fog::AWS::Mock.network_acl_association_id
+            self.data[:network_acls][network_acl_id]['associationSet'] << {
+              'networkAclAssociationId' => id,
+              'networkAclId'            => network_acl_id,
+              'subnetId'                => subnet_id,
+            }
+
+            response.status = 200
+            response.body = {
+              'requestId'        => Fog::AWS::Mock.request_id,
+              'newAssociationId' => id
+            }
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/basic'
+
+        # Replaces a Network ACL entry with the same rule number
+        #
+        # ==== Parameters
+        # * network_acl_id<~String> - The ID of the ACL to add this entry to
+        # * rule_number<~Integer>   - The rule number for the entry, between 100 and 32766
+        # * protocol<~Integer>      - The IP protocol to which the rule applies. You can use -1 to mean all protocols.
+        # * rule_action<~String>    - Allows or denies traffic that matches the rule. (either allow or deny)
+        # * cidr_block<~String>     - The CIDR range to allow or deny
+        # * egress<~Boolean>        - Indicates whether this rule applies to egress traffic from the subnet (true) or ingress traffic to the subnet (false).
+        # * options<~Hash>:
+        # *   'Icmp.Code'           - ICMP code, required if protocol is 1
+        # *   'Icmp.Type'           - ICMP type, required if protocol is 1
+        # *   'PortRange.From'      - The first port in the range, required if protocol is 6 (TCP) or 17 (UDP)
+        # *   'PortRange.To'        - The last port in the range, required if protocol is 6 (TCP) or 17 (UDP)
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'return'<~Boolean> - Returns true if the request succeeds.
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-ReplaceNetworkAclEntry.html]
+        def replace_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {})
+          request({
+            'Action'       => 'ReplaceNetworkAclEntry',
+            'NetworkAclId' => network_acl_id,
+            'RuleNumber'   => rule_number,
+            'Protocol'     => protocol,
+            'RuleAction'   => rule_action,
+            'Egress'       => egress,
+            'CidrBlock'    => cidr_block,
+            :parser        => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(options))
+        end
+      end
+
+      class Mock
+        def replace_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {})
+          response = Excon::Response.new
+          if self.data[:network_acls][network_acl_id]
+
+            unless self.data[:network_acls][network_acl_id]['entrySet'].detect { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
+              raise Fog::Compute::AWS::Error.new("No rule with that number")
+            end
+            self.data[:network_acls][network_acl_id]['entrySet'].delete_if { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
+
+            data = {
+              'ruleNumber'   => rule_number,
+              'protocol'     => protocol,
+              'ruleAction'   => rule_action,
+              'egress'       => egress,
+              'cidrBlock'    => cidr_block,
+              'icmpTypeCode' => {},
+              'portRange'    => {}
+            }
+            data['icmpTypeCode']['code'] = options['Icmp.Code']      if options['Icmp.Code']
+            data['icmpTypeCode']['type'] = options['Icmp.Type']      if options['Icmp.Type']
+            data['portRange']['from']    = options['PortRange.From'] if options['PortRange.From']
+            data['portRange']['to']      = options['PortRange.To']   if options['PortRange.To']
+            self.data[:network_acls][network_acl_id]['entrySet'] << data
+
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/basic'
+
+        # Replaces a route in a route table within a VPC.
+        #
+        # ==== Parameters
+        # * RouteTableId<~String> - The ID of the route table for the route.
+        # * options<~Hash>:
+        #   * DestinationCidrBlock<~String> - The CIDR address block used for the destination match. Routing decisions are based on the most specific match.
+        #   * GatewayId<~String> - The ID of an Internet gateway attached to your VPC.
+        #   * InstanceId<~String> - The ID of a NAT instance in your VPC. The operation fails if you specify an instance ID unless exactly one network interface is attached.
+        #   * NetworkInterfaceId<~String> - The ID of a network interface.
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of the request
+        # * 'return'<~Boolean> - Returns true if the request succeeds. Otherwise, returns an error.
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-ReplaceRoute.html]
+        def replace_route(route_table_id, destination_cidr_block, options = {})
+          options['DestinationCidrBlock'] ||= destination_cidr_block
+
+          request({
+            'Action' => 'ReplaceRoute',
+            'RouteTableId' => route_table_id,
+            :idempotent => true,
+            :parser => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(options))
+
+        end
+      end
+
+      class Mock
+
+        def replace_route(route_table_id, destination_cidr_block, options = {})
+          options['instanceOwnerId'] ||= nil
+          options['DestinationCidrBlock'] ||= destination_cidr_block
+
+          route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? route_table_id }
+          if !route_table.nil? && destination_cidr_block
+            if !options['gatewayId'].nil? || !options['instanceId'].nil? || !options['networkInterfaceId'].nil?
+              if !options['gatewayId'].nil? && self.internet_gateways.all('internet-gateway-id'=>options['gatewayId']).first.nil?
+                raise Fog::Compute::AWS::NotFound.new("The gateway ID '#{options['gatewayId']}' does not exist")
+              elsif !options['instanceId'].nil? && self.servers.all('instance-id'=>options['instanceId']).first.nil?
+                raise Fog::Compute::AWS::NotFound.new("The instance ID '#{options['instanceId']}' does not exist")
+              elsif !options['networkInterfaceId'].nil? && self.network_interfaces.all('networkInterfaceId'=>options['networkInterfaceId']).first.nil?
+                raise Fog::Compute::AWS::NotFound.new("The networkInterface ID '#{options['networkInterfaceId']}' does not exist")
+              elsif route_table['routeSet'].find { |route| route['destinationCidrBlock'].eql? destination_cidr_block }.nil?
+                raise Fog::Compute::AWS::Error, "RouteAlreadyExists => The route identified by #{destination_cidr_block} doesn't exist."
+              else
+                response = Excon::Response.new
+                route_set = route_table['routeSet'].find { |routeset| routeset['destinationCidrBlock'].eql? destination_cidr_block }
+                route_set.merge!(options)
+                route_set['state'] = 'pending'
+                route_set['origin'] = 'ReplaceRoute'
+
+                response.status = 200
+                response.body = {
+                  'requestId'=> Fog::AWS::Mock.request_id,
+                  'return' => true
+                }
+                response
+              end
+            else
+              message = 'MissingParameter => '
+              message << 'The request must contain either a gateway id, a network interface id, or an instance id'
+              raise Fog::Compute::AWS::Error.new(message)
+            end
+          elsif route_table.nil?
+            raise Fog::Compute::AWS::NotFound.new("The routeTable ID '#{route_table_id}' does not exist")
+          elsif destination_cidr_block.empty?
+            raise Fog::Compute::AWS::InvalidParameterValue.new("Value () for parameter destinationCidrBlock is invalid. This is not a valid CIDR block.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -75,6 +75,14 @@ module Fog
             options['LaunchSpecification.UserData'] = Base64.encode64(options['LaunchSpecification.UserData'])
           end
 
+          if options['ValidFrom'] && options['ValidFrom'].is_a?(Time)
+            options['ValidFrom'] =  options['ValidFrom'].iso8601
+          end
+
+          if options['ValidUntil'] && options['ValidUntil'].is_a?(Time)
+            options['ValidUntil'] =  options['ValidUntil'].iso8601
+          end
+
           request({
             'Action'                            => 'RequestSpotInstances',
             'LaunchSpecification.ImageId'       => image_id,

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

@@ -36,7 +36,7 @@ module Fog
         #   * 'SecurityGroupId'<~Array> or <~String> - id's of security group(s) for instances, use this or SecurityGroup
         #   * 'InstanceInitiatedShutdownBehaviour'<~String> - specifies whether volumes are stopped or terminated when instance is shutdown, in [stop, terminate]
         #   * 'InstanceType'<~String> - Type of instance to boot. Valid options
-        #     in ['t1.micro', 'm1.small', 'm1.large', 'm1.xlarge', 'c1.medium', 'c1.xlarge', 'm2.xlarge', m2.2xlarge', 'm2.4xlarge', 'cc1.4xlarge', 'cc2.8xlarge', 'cg1.4xlarge']
+        #     in ['t1.micro', 'm1.small', 'm1.medium', 'm1.large', 'm1.xlarge', 'c1.medium', 'c1.xlarge', 'c3.large', 'c3.xlarge', 'c3.2xlarge', 'c3.4xlarge', 'c3.8xlarge', 'g2.2xlarge', 'hs1.8xlarge', 'm2.xlarge', 'm2.2xlarge', 'm2.4xlarge', 'cr1.8xlarge', 'm3.xlarge', 'm3.2xlarge', 'hi1.4xlarge', 'cc1.4xlarge', 'cc2.8xlarge', 'cg1.4xlarge', 'i2.xlarge', 'i2.2xlarge', 'i2.4xlarge', 'i2.8xlarge']
         #     default is 'm1.small'
         #   * 'KernelId'<~String> - Id of kernel with which to launch
         #   * 'KeyName'<~String> - Name of a keypair to add to booting instances
@@ -139,11 +139,31 @@ module Fog
 
           min_count.times do |i|
             instance_id = Fog::AWS::Mock.instance_id
+            availability_zone = options['Placement.AvailabilityZone'] || Fog::AWS::Mock.availability_zone(@region)
+
+            block_device_mapping = (options['BlockDeviceMapping'] || []).inject([]) do |mapping, device|
+              device_name           = device.fetch("DeviceName", "/dev/sda1")
+              volume_size           = device.fetch("Ebs.VolumeSize", 15)            # @todo should pull this from the image
+              delete_on_termination = device.fetch("Ebs.DeleteOnTermination", true) # @todo should pull this from the image
+
+              volume_id = create_volume(availability_zone, volume_size).data[:body]["volumeId"]
+
+              self.data[:volumes][volume_id].merge!("DeleteOnTermination" => delete_on_termination)
+
+              mapping << {
+                "deviceName"          => device_name,
+                "volumeId"            => volume_id,
+                "status"              => "attached",
+                "attachTime"          => Time.now,
+                "deleteOnTermination" => delete_on_termination,
+              }
+            end
+
             instance = {
               'amiLaunchIndex'      => i,
               'associatePublicIP'   => options['associatePublicIP'] || false,
               'architecture'        => 'i386',
-              'blockDeviceMapping'  => [],
+              'blockDeviceMapping'  => block_device_mapping,
               'clientToken'         => options['clientToken'],
               'dnsName'             => nil,
               'ebsOptimized'        => options['EbsOptimized'] || false,
@@ -156,7 +176,7 @@ module Fog
               'keyName'             => options['KeyName'],
               'launchTime'          => Time.now,
               'monitoring'          => { 'state' => options['Monitoring.Enabled'] || false },
-              'placement'           => { 'availabilityZone' => options['Placement.AvailabilityZone'] || Fog::AWS::Mock.availability_zone(@region), 'groupName' => nil, 'tenancy' => options['Placement.Tenancy'] || 'default' },
+              'placement'           => { 'availabilityZone' => availability_zone, 'groupName' => nil, 'tenancy' => options['Placement.Tenancy'] || 'default' },
               'privateDnsName'      => nil,
               'productCodes'        => [],
               'reason'              => nil,

data/lib/fog/aws/requests/data_pipeline/put_pipeline_definition.rb

@@ -28,35 +28,43 @@ module Fog
 
         # Take a list of pipeline object hashes as specified in the Data Pipeline JSON format
         # and transform it into the format expected by the API
-        private
         def transform_objects(objects)
-          output = []
+          objects.map { |object| JSONObject.new(object).to_api }
+        end
 
-          objects.each do |object|
-            new_object = {}
-            new_object['id'] = object.delete('id')
-            new_object['name'] = object.delete('name') || new_object['id']
+        class JSONObject
+          def initialize(object)
+            @json_fields = object.clone
+            @id = @json_fields.delete('id')
+            @name = @json_fields.delete('name') || @id
+          end
 
-            new_object['fields'] = []
-            object.each do |key, value|
-              if value.is_a?(Hash)
-                new_object['fields'] << { 'key' => key, 'refValue' => value['ref'] }
+          def to_api
+            {
+              'id' => @id,
+              'name' => @name,
+              'fields' => fields
+            }
+          end
 
-              elsif value.is_a?(Array)
-                value.each do |v|
-                  new_object['fields'] << { 'key' => key, 'stringValue' => v }
-                end
+        private
 
-              else
-                new_object['fields'] << { 'key' => key, 'stringValue' => value }
+          def fields
+            @json_fields.map{|k,v| field_for_kv(k,v)}.flatten
+          end
 
-              end
-            end
+          def field_for_kv(key, value)
+            if value.is_a?(Hash)
+              { 'key' => key, 'refValue' => value['ref'] }
 
-            output << new_object
-          end
+            elsif value.is_a?(Array)
+              value.map { |subvalue| field_for_kv(key, subvalue) }
+
+            else
+              { 'key' => key, 'stringValue' => value }
 
-          output
+            end
+          end
         end
 
       end

data/lib/fog/aws/requests/elasticache/create_cache_cluster.rb

@@ -12,6 +12,7 @@ module Fog
         # * options <~Hash> - All optional parameters should be set in this Hash:
         #   * :node_type <~String> - The size (flavor) of the cache Nodes
         #   * :security_group_names <~Array> - Array of Elasticache::SecurityGroup names
+        #   * :vpc_security_groups <~Array> - Array
         #   * :num_nodes <~Integer> - The number of nodes in the Cluster
         #   * :auto_minor_version_upgrade <~TrueFalseClass>
         #   * :parameter_group_name <~String> - Name of the Cluster's ParameterGroup
@@ -21,20 +22,13 @@ module Fog
         #   * :port <~Integer> - The memcached port number
         #   * :preferred_availablility_zone <~String>
         #   * :preferred_maintenance_window <~String>
+        #   * :cache_subnet_group_name <~String>
         # === Returns
         # * response <~Excon::Response>:
         #   * body <~Hash>
         def create_cache_cluster(id, options = {})
-          # Construct Cache Security Group parameters in the format:
-          #   CacheSecurityGroupNames.member.N => "security_group_name"
-          group_names = options[:security_group_names] || ['default']
-          sec_group_params = group_names.inject({}) do |group_hash, name|
-            index = group_names.index(name) + 1
-            group_hash["CacheSecurityGroupNames.member.#{index}"] = name
-            group_hash
-          end
-          # Merge the Cache Security Group parameters with the normal options
-          request(sec_group_params.merge(
+
+          req_options = {
             'Action'          => 'CreateCacheCluster',
             'CacheClusterId'  => id.strip,
             'CacheNodeType'   => options[:node_type]  || 'cache.m1.large',
@@ -42,13 +36,25 @@ module Fog
             'NumCacheNodes'   => options[:num_nodes]  || 1,
             'AutoMinorVersionUpgrade'     => options[:auto_minor_version_upgrade],
             'CacheParameterGroupName'     => options[:parameter_group_name],
+            'CacheSubnetGroupName'        => options[:cache_subnet_group_name],
             'EngineVersion'               => options[:engine_version],
             'NotificationTopicArn'        => options[:notification_topic_arn],
             'Port'                        => options[:port],
             'PreferredAvailabilityZone'   => options[:preferred_availablility_zone],
             'PreferredMaintenanceWindow'  => options[:preferred_maintenance_window],
             :parser => Fog::Parsers::AWS::Elasticache::SingleCacheCluster.new
-          ))
+          }
+
+          if cache_security_groups = options.delete(:security_group_names)
+              req_options.merge!(Fog::AWS.indexed_param('CacheSecurityGroupNames.member.%d', [*cache_security_groups]))
+          end
+
+          if vpc_security_groups = options.delete(:vpc_security_groups)
+              req_options.merge!(Fog::AWS.indexed_param('SecurityGroupIds.member.%d', [*vpc_security_groups]))
+          end
+
+          request( req_options )
+
         end
       end
 
@@ -66,6 +72,7 @@ module Fog
             'CacheSecurityGroups' => [],
             'CacheParameterGroup' => { 'CacheParameterGroupName' =>
                 options[:parameter_group_name] || 'default.memcached1.4' },
+            'CacheSubnetGroupName' => options[:cache_subnet_group_name],
             'PendingModifiedValues'       => {},
             'AutoMinorVersionUpgrade'     =>
               options[:auto_minor_version_upgrade]    || 'true',