fog 1.3.1 → 1.4.0

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

@@ -5,10 +5,20 @@ module Fog
 
         require 'fog/aws/parsers/compute/describe_instance_status'
 
+        # http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeInstanceStatus.html
+        #
         def describe_instance_status(filters = {})
           raise ArgumentError.new("Filters must be a hash, but is a #{filters.class}.") unless filters.is_a?(Hash)
+          next_token = filters.delete('nextToken') || filters.delete('NextToken')
+          max_results = filters.delete('maxResults') || filters.delete('MaxResults')
+
+          params = Fog::AWS.indexed_request_param('InstanceId', filters.delete('InstanceId'))
+
+          params.merge!(Fog::AWS.indexed_filters(filters))
+
+          params['NextToken'] = next_token if next_token
+          params['MaxResults'] = max_results if max_results
 
-          params = Fog::AWS.indexed_filters(filters)
           request({
             'Action'    => 'DescribeInstanceStatus',
             :idempotent => true,

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

@@ -183,6 +183,9 @@ module Fog
               end
             when 'rebooting'
               instance['instanceState'] = { 'code' => 16, 'name' => 'running' }
+            when 'stopping'
+              instance['instanceState'] = { 'code' => 0, 'name' => 'stopping' }
+              instance['stateReason'] = { 'code' => 0 }
             when 'shutting-down'
               if Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay * 2
                 self.data[:deleted_at].delete(instance['instanceId'])

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

@@ -0,0 +1,61 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/describe_internet_gateways'
+
+        # Describe all or specified internet_gateways
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'InternetGatewaySet'<~Array>:
+        #   * 'internetGatewayId'<~String> - The ID of the Internet gateway. 
+        #   * 'attachmentSet'<~Array>: - A list of VPCs attached to the Internet gateway
+        #     * 'vpcId'<~String> - The ID of the VPC the Internet gateway is attached to
+        #     * 'state'<~String> - The current state of the attachment
+        # * 'tagSet'<~Array>: Tags assigned to the resource.
+        #   * 'key'<~String> - Tag's key
+        #   * 'value'<~String> - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-ItemType-InternetGatewayType.html]
+        def describe_internet_gateways(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.warning("describe_internet_gateways with #{filters.class} param is deprecated, use internet_gateways('internet-gateway-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'internet-gateway-id' => [*filters]}
+          end
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action' => 'DescribeInternetGateways',
+            :idempotent => true,
+            :parser => Fog::Parsers::Compute::AWS::DescribeInternetGateways.new
+          }.merge!(params))
+        end
+      end
+      
+      class Mock
+        def describe_internet_gateways(filters = {})
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'internetGatewaySet'    => [
+                'internetGatewayId'      => Fog::AWS::Mock.request_id,
+                'attachmentSet'          => {
+                  'vpcId'                  => Fog::AWS::Mock.request_id,
+                  'state'                  => 'pending',
+                },
+                'tagSet'                 =>  {}
+              ]
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/describe_network_interface_attribute'
+        # Describes a network interface attribute value
+        #
+        # ==== Parameters
+        # * network_interface_id<~String> - The ID of the network interface you want to describe an attribute of
+        # * attribute<~String>            - The attribute to describe, must be one of 'description', 'groupSet', 'sourceDestCheck' or 'attachment'
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'networkInterfaceId'<~String> - The ID of the network interface
+        # * 'description'<~String>        - The description (if requested)
+        # * 'groupSet'<~Hash>             - Associated security groups (if requested)
+        # *   'key'<~String>              - ID of associated group
+        # *   'value'<~String>            - Name of associated group
+        # * 'sourceDestCheck'<~Boolean>   - Flag indicating whether traffic to or from the instance is validated (if requested)
+        # * 'attachment'<~Hash>:          - Describes the way this nic is attached  (if requested)
+        # *   'attachmentID'<~String>
+        # *   'instanceID'<~String>
+        # *   'instanceOwnerId'<~String>
+        # *   'deviceIndex'<~Integer>
+        # *   'status'<~String>
+        # *   'attachTime'<~String>
+        # *   'deleteOnTermination<~Boolean>
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2012-03-01/APIReference/ApiReference-query-DescribeNetworkInterfaceAttribute.html]
+        def describe_network_interface_attribute(network_interface_id, attribute)
+          request(
+            'Action'             => 'DescribeNetworkInterfaceAttribute',
+            'NetworkInterfaceId' => network_interface_id,
+            'Attribute'          => attribute,
+            :parser              => Fog::Parsers::Compute::AWS::DescribeNetworkInterfaceAttribute.new
+          )
+        end
+      end
+      
+      class Mock
+        def describe_network_interface_attribute(network_interface_id, attribute)
+          response = Excon::Response.new
+          if self.data[:network_interfaces][network_interface_id]
+
+            response.status = 200
+            response.body = {
+              'requestId'          => Fog::AWS::Mock.request_id,
+              'networkInterfaceId' => network_interface_id
+            }
+            case attribute
+            when 'description', 'groupSet', 'sourceDestCheck', 'attachment'
+              response.body[attribute] = self.data[:network_interfaces][network_interface_id][attribute]
+            else
+              raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
+            end
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The network interface '#{network_interface_id}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/describe_network_interfaces'
+
+        # Describe all or specified network interfaces
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'networkInterfaceSet'<~Array>:
+        # *   'networkInterfaceId'<~String> - The ID of the network interface
+        # *   'subnetId'<~String>           - The ID of the subnet
+        # *   'vpcId'<~String>              - The ID of the VPC
+        # *   'availabilityZone'<~String>   - The availability zone
+        # *   'description'<~String>        - The description
+        # *   'ownerId'<~String>            - The ID of the person who created the interface
+        # *   'requesterId'<~String>        - The ID ot teh entity requesting this interface
+        # *   'requesterManaged'<~String>   - 
+        # *   'status'<~String>             - "available" or "in-use"
+        # *   'macAddress'<~String>         - 
+        # *   'privateIpAddress'<~String>   - IP address of the interface within the subnet
+        # *   'privateDnsName'<~String>     - The private DNS name
+        # *   'sourceDestCheck'<~Boolean>   - Flag indicating whether traffic to or from the instance is validated
+        # *   'groupSet'<~Hash>             - Associated security groups
+        # *     'key'<~String>              - ID of associated group
+        # *     'value'<~String>            - Name of associated group
+        # *   'attachment'<~Hash>:          - Describes the way this nic is attached
+        # *     'attachmentID'<~String>
+        # *     'instanceID'<~String>
+        # *     'instanceOwnerId'<~String>
+        # *     'deviceIndex'<~Integer>
+        # *     'status'<~String>
+        # *     'attachTime'<~String>
+        # *     'deleteOnTermination'<~Boolean>
+        # *   'association'<~Hash>:         - Describes an eventual instance association
+        # *     'attachmentID'<~String>     - ID of the network interface attachment
+        # *     'instanceID'<~String>       - ID of the instance attached to the network interface
+        # *     'publicIp'<~String>         - Address of the Elastic IP address bound to the network interface
+        # *     'ipOwnerId'<~String>        - ID of the Elastic IP address owner
+        # *   'tagSet'<~Array>:             - Tags assigned to the resource.
+        # *     'key'<~String>              - Tag's key
+        # *     'value'<~String>            - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2012-03-01/APIReference/index.html?ApiReference-query-DescribeNetworkInterfaces.html]
+        def describe_network_interfaces(filters = {})
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action' => 'DescribeNetworkInterfaces',
+            :idempotent => true,
+            :parser => Fog::Parsers::Compute::AWS::DescribeNetworkInterfaces.new
+          }.merge!(params))
+        end
+      end
+      
+
+      class Mock
+
+        def describe_network_interfaces(filters = {})
+          response = Excon::Response.new
+
+          network_interface_info = self.data[:network_interfaces].values
+
+          for filter_key, filter_value in filters
+            network_interface_info = network_interface_info.reject{|nic| ![*filter_value].include?(nic[filter_key])}
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId'           => Fog::AWS::Mock.request_id,
+            'networkInterfaceSet' => network_interface_info
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -10,19 +10,14 @@ module Fog
           raise ArgumentError.new("Filters must be a hash, but is a #{filters.class}.") unless filters.is_a?(Hash)
           next_token = filters.delete('nextToken') || filters.delete('NextToken')
           max_results = filters.delete('maxResults') || filters.delete('MaxResults')
-          volume_ids = filters.delete('VolumeId')
 
-          params = Fog::AWS.indexed_filters(filters)
+          params = Fog::AWS.indexed_request_param('VolumeId', filters.delete('VolumeId'))
+
+          params.merge!(Fog::AWS.indexed_filters(filters))
 
           params['NextToken'] = next_token if next_token
           params['MaxResults'] = max_results if max_results
 
-          Array(volume_ids).inject(1) do |idx, vid|
-            params["VolumeId.#{idx}"] = vid
-            idx += 1
-          end
-
-          pp params
           request({
             'Action'    => 'DescribeVolumeStatus',
             :idempotent => true,

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

@@ -0,0 +1,56 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/detach_internet_gateway'
+        # Detaches an Internet gateway to a VPC, enabling connectivity between the Internet and the VPC
+        #
+        # ==== Parameters
+        # * internet_gateway_id<~String> - The ID of the Internet gateway to detach
+        # * vpc_id<~String> - The ID of the VPC
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - Returns true if the request succeeds.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DetachInternetGateway.html]
+        def detach_internet_gateway(internet_gateway_id, vpc_id)
+          request(
+            'Action'               => 'DetachInternetGateway',
+            'InternetGatewayId'    => internet_gateway_id,
+            'VpcId'                => vpc_id,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::Compute::AWS::DetachInternetGateway.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def detach_internet_gateway(internet_gateway_id, vpc_id)
+          response = Excon::Response.new
+          if internet_gateway_id && vpc_id
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return' => true
+            }
+            response
+          else
+            if !internet_gateway_id
+              message << 'The request must contain the parameter internet_gateway_id'
+            elsif !vpc_id
+              message << 'The request must contain the parameter vpc_id'
+            end
+            raise Fog::Compute::AWS::Error.new(message)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/detach_network_interface'
+        # Detaches a network interface.
+        #
+        # ==== Parameters
+        # * attachment_id<~String> - ID of the attachment to detach
+        # * force<~Boolean>        - Set to true to force a detachment
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'return'<~Boolean>   - Returns true if the request succeeds.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2012-03-01/APIReference/ApiReference-query-DetachNetworkInterface.html]
+        def detach_network_interface(attachment_id, force = false)
+          request(
+            'Action'       => 'DetachNetworkInterface',
+            'AttachmentId' => attachment_id,
+            'Force'        => force,
+            :parser        => Fog::Parsers::Compute::AWS::DetachNetworkInterface.new
+          )
+        end
+      end
+      
+      class Mock
+        def detach_network_interface(attachment_id, force = false)
+          response = Excon::Response.new
+          nic_id = self.data[:network_interfaces].select { |k,v| v['attachment']['attachmentId'] == attachment_id} .first.first
+          if nic_id
+            self.data[:network_interfaces][nic_id]["attachment"] = {}
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The network interface '#{network_interface_id}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/basic'
+
+        # Modifies a network interface attribute value
+        #
+        # ==== Parameters
+        # * network_interface_id<~String> - The ID of the network interface you want to describe an attribute of
+        # * attribute<~String>            - The attribute to modify, must be one of 'description', 'groupSet', 'sourceDestCheck' or 'attachment'
+        # * value<~Object>                - New value of attribute, the actual tyep depends on teh attribute:
+        #                                   description     - a string
+        #                                   groupSet        - a list of group id's
+        #                                   sourceDestCheck - a boolean value
+        #                                   attachment      - a hash with:
+        #                                                       attachmentid - the attachment to change
+        #                                                       deleteOnTermination - a boolean
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2012-03-01/APIReference/ApiReference-query-ModifyNetworkInterfaceAttribute.html]
+        def modify_network_interface_attribute(network_interface_id, attribute, value)
+          params = {}
+          case attribute
+          when 'description'
+            params['Description.Value'] = value
+          when 'groupSet'
+            params.merge!(Fog::AWS.indexed_param('SecurityGroupId.%d', value))
+          when 'sourceDestCheck'
+            params['SourceDestCheck.Value'] = value
+          when 'attachment'
+            params['Attachment.AttachmentId']        = value['attachmentId']
+            params['Attachment.DeleteOnTermination'] = value['deleteOnTermination']
+          else
+            raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
+          end
+
+          request({
+            'Action'             => 'ModifyNetworkInterfaceAttribute',
+            'NetworkInterfaceId' => network_interface_id,
+            :parser              => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(params))
+        end
+      end
+      
+      class Mock
+        def modify_network_interface_attribute(network_interface_id, attribute, value)
+          response = Excon::Response.new
+          if self.data[:network_interfaces][network_interface_id]
+            nic = self.data[:network_interfaces][network_interface_id]
+            
+            case attribute
+            when 'description'
+              nic['description'] = value.clone
+            when 'groupSet'
+              groups = {}
+              value.each do |group_id|
+                name = self.data[:security_groups].select { |k,v| v['groupId'] == group_id } .first.first
+                if name.nil?
+                  raise Fog::Compute::AWS::Error.new("Unknown security group '#{group_id}' specified")
+                end
+                groups[group_id] = name
+              end
+              nic['groupSet'] = groups
+            when 'sourceDestCheck'
+              nic['sourceDestCheck'] = value
+            when 'attachment'
+              if nic['attachment'].nil? || value['attachmentId'] != nic['attachment']['attachmentId']
+                raise Fog::Compute::AWS::Error.new("Illegal attachment '#{value['attachmentId']}' specified")
+              end
+              nic['attachment']['deleteOnTermination'] = value['deleteOnTermination']
+            else
+              raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
+            end
+
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The network interface '#{network_interface_id}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end