fog-aws 0.0.5

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

@@ -0,0 +1,64 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_key_pairs'
+
+        # Describe all or specified key pairs
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'keySet'<~Array>:
+        #       * 'keyName'<~String> - Name of key
+        #       * 'keyFingerprint'<~String> - Fingerprint of key
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeKeyPairs.html]
+        def describe_key_pairs(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.deprecation("describe_key_pairs with #{filters.class} param is deprecated, use describe_key_pairs('key-name' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'key-name' => [*filters]}
+          end
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeKeyPairs',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeKeyPairs.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_key_pairs(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.deprecation("describe_key_pairs with #{filters.class} param is deprecated, use describe_key_pairs('key-name' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'key-name' => [*filters]}
+          end
+
+          response = Excon::Response.new
+
+          key_set = self.data[:key_pairs].values
+
+          aliases = {'fingerprint' => 'keyFingerprint', 'key-name' => 'keyName'}
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            key_set = key_set.reject{|key_pair| ![*filter_value].include?(key_pair[aliased_key])}
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'keySet'    => key_set.map do |key_pair|
+              key_pair.reject {|key,value| !['keyFingerprint', 'keyName'].include?(key)}
+            end
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_network_acls'
+
+        # Describe all or specified network ACLs
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String>                   - Id of request
+        # * 'networkAclSet'<~Array>:               - A list of network ACLs
+        # *   'networkAclId'<~String>              - The ID of the network ACL
+        # *   'vpcId'<~String>                     - The ID of the VPC for the network ACL
+        # *   'default'<~Boolean>                  - Indicates whether this is the default network ACL for the VPC
+        # *   'entrySet'<~Array>:                  - A list of entries (rules) in the network ACL
+        # *     'ruleNumber'<~Integer>             - The rule number for the entry. ACL entries are processed in ascending order by rule number
+        # *     'protocol'<~Integer>               - The protocol. A value of -1 means all protocols
+        # *     'ruleAction'<~String>              - Indicates whether to allow or deny the traffic that matches the rule
+        # *     'egress'<~Boolean>                 - Indicates whether the rule is an egress rule (applied to traffic leaving the subnet)
+        # *     'cidrBlock'<~String>               - The network range to allow or deny, in CIDR notation
+        # *     'icmpTypeCode'<~Hash>              - ICMP protocol: The ICMP type and code
+        # *       'code'<~Integer>                 - The ICMP code. A value of -1 means all codes for the specified ICMP type
+        # *       'type'<~Integer>                 - The ICMP type. A value of -1 means all types
+        # *     'portRange'<~Hash>                 - TCP or UDP protocols: The range of ports the rule applies to
+        # *       'from'<~Integer>                 - The first port in the range
+        # *       'to'<~Integer>                   - The last port in the range
+        # *   'associationSet'<~Array>:            - A list of associations between the network ACL and subnets
+        # *     'networkAclAssociationId'<~String> - The ID of the association
+        # *     'networkAclId'<~String>            - The ID of the network ACL
+        # *     'subnetId'<~String>                - The ID of the subnet
+        # *   'tagSet'<~Array>:                    - Tags assigned to the resource.
+        # *     'key'<~String>                     - Tag's key
+        # *     'value'<~String>                   - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeNetworkAcls.html]
+        def describe_network_acls(filters = {})
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action' => 'DescribeNetworkAcls',
+            :idempotent => true,
+            :parser => Fog::Parsers::Compute::AWS::DescribeNetworkAcls.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_network_acls(filters = {})
+          response = Excon::Response.new
+
+          network_acls = self.data[:network_acls].values
+          network_acls = apply_tag_filters(network_acls, filters, 'networkAclId')
+
+          aliases = {
+            'vpc-id'         => 'vpcId',
+            'network-acl-id' => 'networkAclId',
+            'default'        => 'default',
+          }
+          association_aliases = {
+            'association-id' => 'networkAclAssociationId',
+            'network-acl-id' => 'networkAclId',
+            'subnet-id'      => 'subnetId',
+          }
+          entry_aliases = {
+            'cidr'        => 'cidrBlock',
+            'egress'      => 'egress',
+            'rule-action' => 'ruleAction',
+            'rule-number' => 'ruleNumber',
+            'protocol'    => 'protocol'
+          }
+          for filter_key, filter_value in filters
+            filter_key = filter_key.to_s
+            if association_key = filter_key.split('association.')[1]
+              aliased_key = association_aliases[association_key]
+              network_acls = network_acls.reject{|nacl| !nacl['associationSet'].find {|association| [*filter_value].include?(association[aliased_key])}}
+            elsif entry_key = filter_key.split('entry.icmp.')[1]
+              network_acls = network_acls.reject{|nacl| !nacl['entrySet'].find {|association| [*filter_value].include?(association['icmpTypeCode'][entry_key])}}
+            elsif entry_key = filter_key.split('entry.port-range.')[1]
+              network_acls = network_acls.reject{|nacl| !nacl['entrySet'].find {|association| [*filter_value].include?(association['portRange'][entry_key])}}
+            elsif entry_key = filter_key.split('entry.')[1]
+              aliased_key = entry_aliases[entry_key]
+              network_acls = network_acls.reject{|nacl| !nacl['entrySet'].find {|association| [*filter_value].include?(association[aliased_key])}}
+            else
+              aliased_key = aliases[filter_key]
+              network_acls = network_acls.reject{|nacl| ![*filter_value].include?(nacl[aliased_key])}
+            end
+          end
+
+          network_acls.each do |acl|
+            tags = self.data[:tag_sets][acl['networkAclId']]
+            acl.merge!('tagSet' => tags) if tags
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId'     => Fog::AWS::Mock.request_id,
+            'networkAclSet' => network_acls
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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
+        # *   '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 = {})
+          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_placement_groups.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_placement_groups'
+
+        # Describe all or specified placement groups
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'placementGroupSet'<~Array>:
+        #       * 'groupName'<~String> - Name of placement group
+        #       * 'strategy'<~String> - Strategy of placement group
+        #       * 'state'<~String> - State of placement group
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribePlacementGroups.html]
+        def describe_placement_groups(filters = {})
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribePlacementGroups',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribePlacementGroups.new
+          }.merge!(params))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_regions'
+
+        # Describe all or specified regions
+        #
+        # ==== Params
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'regionInfo'<~Array>:
+        #       * 'regionName'<~String> - Name of region
+        #       * 'regionEndpoint'<~String> - Service endpoint for region
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeRegions.html]
+        def describe_regions(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.deprecation("describe_regions with #{filters.class} param is deprecated, use describe_regions('region-name' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'region-name' => [*filters]}
+          end
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeRegions',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeRegions.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_regions(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.deprecation("describe_regions with #{filters.class} param is deprecated, use describe_regions('region-name' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'region-name' => [*filters]}
+          end
+
+          response = Excon::Response.new
+          region_info = [
+            {"regionName"=>"eu-west-1", "regionEndpoint"=>"eu-west-1.ec2.amazonaws.com"},
+            {"regionName"=>"us-east-1", "regionEndpoint"=>"us-east-1.ec2.amazonaws.com"}
+          ]
+
+          aliases = {'region-name' => 'regionName', 'endpoint' => 'regionEndpoint'}
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            region_info = region_info.reject{|region| ![*filter_value].include?(region[aliased_key])}
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId'   => Fog::AWS::Mock.request_id,
+            'regionInfo'  => region_info
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_reserved_instances'
+
+        # Describe all or specified reserved instances
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'reservedInstancesSet'<~Array>:
+        #       * 'availabilityZone'<~String> - availability zone of the instance
+        #       * 'duration'<~Integer> - duration of reservation, in seconds
+        #       * 'fixedPrice'<~Float> - purchase price of reserved instance
+        #       * 'instanceType'<~String> - type of instance
+        #       * 'instanceCount'<~Integer> - number of reserved instances
+        #       * 'productDescription'<~String> - reserved instance description
+        #       * 'reservedInstancesId'<~String> - id of the instance
+        #       * 'start'<~Time> - start time for reservation
+        #       * 'state'<~String> - state of reserved instance purchase, in .[pending-payment, active, payment-failed, retired]
+        #       * 'usagePrice"<~Float> - usage price of reserved instances, per hour
+        #       * 'end' - time reservation stopped being applied (i.e sold or canceled - as of version 2013/10/01)
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeReservedInstances.html]
+        def describe_reserved_instances(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.deprecation("describe_reserved_instances with #{filters.class} param is deprecated, use describe_reserved_instances('reserved-instances-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'reserved-instances-id' => [*filters]}
+          end
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeReservedInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeReservedInstances.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_reserved_instances(filters = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'reservedInstancesSet' => self.data[:reserved_instances].values,
+            'requestId' => Fog::AWS::Mock.request_id
+          }
+
+          response
+        end
+      end
+    end
+  end
+end