fog-aws 0.0.5

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

@@ -0,0 +1,35 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_spot_price_history'
+
+        # Describe all or specified spot price history
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'spotPriceHistorySet'<~Array>:
+        #       * 'availabilityZone'<~String> - availability zone for instance
+        #       * 'instanceType'<~String> - the type of instance
+        #       * 'productDescription'<~String> - general description of AMI
+        #       * 'spotPrice'<~Float> - maximum price to launch one or more instances
+        #       * 'timestamp'<~Time> - date and time of request creation
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeSpotPriceHistory.html]
+        def describe_spot_price_history(filters = {})
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeSpotPriceHistory',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeSpotPriceHistory.new
+          }.merge!(params))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_subnets'
+
+        # Describe all or specified subnets
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'subnetSet'<~Array>:
+        # * 'subnetId'<~String> - The Subnet's ID
+        # * 'state'<~String> - The current state of the Subnet. ['pending', 'available']
+        # * 'vpcId'<~String> - The ID of the VPC the subnet is in
+        # * 'cidrBlock'<~String> - The CIDR block the Subnet covers.
+        # * 'availableIpAddressCount'<~Integer> - The number of unused IP addresses in the subnet (the IP addresses for any
+        #   stopped instances are considered unavailable)
+        # * 'availabilityZone'<~String> - The Availability Zone the subnet is in.
+        # * 'tagSet'<~Array>: Tags assigned to the resource.
+        # * 'key'<~String> - Tag's key
+        # * 'value'<~String> - Tag's value
+        # * 'instanceTenancy'<~String> - The allowed tenancy of instances launched into the Subnet.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2011-07-15/APIReference/index.html?ApiReference-query-DescribeSubnets.html]
+        def describe_subnets(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.warning("describe_subnets with #{filters.class} param is deprecated, use describe_subnets('subnet-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'subnet-id' => [*filters]}
+          end
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeSubnets',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeSubnets.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_subnets(filters = {})
+          subnets = self.data[:subnets]
+
+          # Transition from pending to available
+          subnets.each do |subnet|
+            case subnet['state']
+              when 'pending'
+                subnet['state'] = 'available'
+            end
+          end
+
+          if filters['subnet-id']
+            subnets = subnets.reject {|subnet| subnet['subnetId'] != filters['subnet-id']}
+          end
+
+          Excon::Response.new(
+            :status => 200,
+            :body   => {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'subnetSet' => subnets
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_tags'
+
+        # Describe all or specified tags
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'tagSet'<~Array>:
+        #       * 'resourceId'<~String> - id of resource tag belongs to
+        #       * 'resourceType'<~String> - type of resource tag belongs to
+        #       * 'key'<~String> - Tag's key
+        #       * 'value'<~String> - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeTags.html]
+        def describe_tags(filters = {})
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeTags',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeTags.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_tags(filters = {})
+          response = Excon::Response.new
+
+          tag_set = deep_clone(self.data[:tags])
+
+          aliases = {
+            'key'               => 'key',
+            'resource-id'       => 'resourceId',
+            'resource-type'     => 'resourceType',
+            'value'             => 'value'
+          }
+
+          for filter_key, filter_value in filters
+            filter_attribute = aliases[filter_key]
+            case filter_attribute
+            when 'key'
+              tag_set.reject! { |k,_| k != filter_value }
+            when 'value'
+              tag_set.each { |k,values| values.reject! { |v, _| v != filter_value } }
+            when 'resourceId'
+              filter_resources(tag_set, 'resourceId', filter_value)
+            when 'resourceType'
+              filter_resources(tag_set, 'resourceType', filter_value)
+            end
+          end
+
+          tagged_resources = []
+          tag_set.each do |key, values|
+            values.each do |value, resources|
+              resources.each do |resource|
+                tagged_resources << resource.merge({
+                  'key' => key,
+                  'value' => value
+                })
+              end
+            end
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId'       => Fog::AWS::Mock.request_id,
+            'tagSet'          => tagged_resources
+          }
+          response
+        end
+
+        private
+
+          def filter_resources(tag_set, filter, value)
+            value_hash_list = tag_set.values
+            value_hash_list.each do |value_hash|
+              value_hash.each do |_, resource_list|
+                resource_list.reject! { |resource| resource[filter] != value }
+              end
+            end
+          end
+
+          def deep_clone(obj)
+            case obj
+            when Hash
+              obj.reduce({}) { |h, pair| h[pair.first] = deep_clone(pair.last); h }
+            when Array
+              obj.map { |o| deep_clone(o) }
+            else
+              obj
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_volume_status'
+
+        # http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeVolumeStatus.html
+        def describe_volume_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('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
+
+          request({
+            'Action'    => 'DescribeVolumeStatus',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeVolumeStatus.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_volume_status(filters = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'volumeStatusSet' => [],
+            'requestId' => Fog::AWS::Mock.request_id
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_volumes'
+
+        # Describe all or specified volumes.
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'volumeSet'<~Array>:
+        #       * 'availabilityZone'<~String> - Availability zone for volume
+        #       * 'createTime'<~Time> - Timestamp for creation
+        #       * 'encrypted'<~Boolean> - Indicates whether the volume will be encrypted
+        #       * 'iops'<~Integer> - Number of IOPS volume supports
+        #       * 'size'<~Integer> - Size in GiBs for volume
+        #       * 'snapshotId'<~String> - Snapshot volume was created from, if any
+        #       * 'status'<~String> - State of volume
+        #       * 'volumeId'<~String> - Reference to volume
+        #       * 'volumeType'<~String> - Type of volume
+        #       * 'attachmentSet'<~Array>:
+        #         * 'attachmentTime'<~Time> - Timestamp for attachment
+        #         * 'deleteOnTermination'<~Boolean> - Whether or not to delete volume on instance termination
+        #         * 'device'<~String> - How value is exposed to instance
+        #         * 'instanceId'<~String> - Reference to attached instance
+        #         * 'status'<~String> - Attachment state
+        #         * 'volumeId'<~String> - Reference to volume
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeVolumes.html]
+        def describe_volumes(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.deprecation("describe_volumes with #{filters.class} param is deprecated, use describe_volumes('volume-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'volume-id' => [*filters]}
+          end
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeVolumes',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeVolumes.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_volumes(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.deprecation("describe_volumes with #{filters.class} param is deprecated, use describe_volumes('volume-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'volume-id' => [*filters]}
+          end
+
+          response = Excon::Response.new
+
+          volume_set = self.data[:volumes].values
+          volume_set = apply_tag_filters(volume_set, filters, 'volumeId')
+
+          aliases = {
+            'availability-zone' => 'availabilityZone',
+            'create-time' => 'createTime',
+            'encrypted' => 'encrypted',
+            'size' => 'size',
+            'snapshot-id' => 'snapshotId',
+            'status' => 'status',
+            'volume-id' => 'volumeId'
+          }
+          attachment_aliases = {
+            'attach-time' => 'attachTime',
+            'delete-on-termination' => 'deleteOnTermination',
+            'device'      => 'device',
+            'instance-id' => 'instanceId',
+            'status'      => 'status'
+          }
+
+          for filter_key, filter_value in filters
+            if attachment_key = filter_key.split('attachment.')[1]
+              aliased_key = attachment_aliases[filter_key]
+              volume_set = volume_set.reject{|volume| !volume['attachmentSet'].find {|attachment| [*filter_value].include?(attachment[aliased_key])}}
+            else
+              aliased_key = aliases[filter_key]
+              volume_set = volume_set.reject{|volume| ![*filter_value].include?(volume[aliased_key])}
+            end
+          end
+
+          volume_set.each do |volume|
+            case volume['status']
+            when 'attaching'
+              if Time.now - volume['attachmentSet'].first['attachTime'] >= Fog::Mock.delay
+                volume['attachmentSet'].first['status'] = 'in-use'
+                volume['status'] = 'in-use'
+              end
+            when 'creating'
+              if Time.now - volume['createTime'] >= Fog::Mock.delay
+                volume['status'] = 'available'
+              end
+            when 'deleting'
+              if Time.now - self.data[:deleted_at][volume['volumeId']] >= Fog::Mock.delay
+                self.data[:deleted_at].delete(volume['volumeId'])
+                self.data[:volumes].delete(volume['volumeId'])
+              end
+            end
+          end
+          volume_set = volume_set.reject {|volume| !self.data[:volumes][volume['volumeId']]}
+          volume_set = volume_set.map {|volume| volume.merge('tagSet' => self.data[:tag_sets][volume['volumeId']]) }
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'volumeSet' => volume_set
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_vpc_attribute'
+        # Describes a vpc attribute value
+        #
+        # ==== Parameters
+        # * vpc_id<~String>    - The ID of the VPC you want to describe an attribute of
+        # * attribute<~String> - The attribute to describe, must be one of 'enableDnsSupport' or 'enableDnsHostnames'
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String>           - Id of request
+        # * 'vpcId'<~String>               - The ID of the VPC
+        # * 'enableDnsSupport'<~Boolean>   - Flag indicating whether DNS resolution is enabled for the VPC (if requested)
+        # * 'enableDnsHostnames'<~Boolean> - Flag indicating whether the instances launched in the VPC get DNS hostnames (if requested)
+        #
+        # (Amazon API Reference)[http://docs.amazonwebservices.com/AWSEC2/2014-02-01/APIReference/ApiReference-query-DescribeVpcAttribute.html]
+        def describe_vpc_attribute(vpc_id, attribute)
+          request(
+            'Action'    => 'DescribeVpcAttribute',
+            'VpcId'     => vpc_id,
+            'Attribute' => attribute,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeVpcAttribute.new
+          )
+        end
+      end
+
+      class Mock
+        def describe_vpc_attribute(vpc_id, attribute)
+          response = Excon::Response.new
+          if vpc = self.data[:vpcs].find{ |v| v['vpcId'] == vpc_id }
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'vpcId'     => vpc_id
+            }
+
+            case attribute
+            when 'enableDnsSupport', 'enableDnsHostnames'
+              response.body[attribute] = vpc[attribute]
+            else
+              raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
+            end
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The VPC '#{vpc_id}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_vpcs'
+
+        # Describe all or specified vpcs
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'vpcSet'<~Array>:
+        # * 'vpcId'<~String> - The VPC's ID
+        # * 'state'<~String> - The current state of the VPC. ['pending', 'available']
+        # * 'cidrBlock'<~String> - The CIDR block the VPC covers.
+        # * 'dhcpOptionsId'<~String> - The ID of the set of DHCP options.
+        # * 'tagSet'<~Array>: Tags assigned to the resource.
+        # * 'key'<~String> - Tag's key
+        # * 'value'<~String> - Tag's value
+        # * 'instanceTenancy'<~String> - The allowed tenancy of instances launched into the VPC.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2011-07-15/APIReference/index.html?ApiReference-query-DescribeVpcs.html]
+        def describe_vpcs(filters = {})
+          unless filters.is_a?(Hash)
+            Fog::Logger.warning("describe_vpcs with #{filters.class} param is deprecated, use describe_vpcs('vpc-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'vpc-id' => [*filters]}
+          end
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action' => 'DescribeVpcs',
+            :idempotent => true,
+            :parser => Fog::Parsers::Compute::AWS::DescribeVpcs.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_vpcs(filters = {})
+          vpcs = self.data[:vpcs]
+          vpcs = apply_tag_filters(vpcs, filters, 'vpcId')
+
+          # Transition from pending to available
+          vpcs.each do |vpc|
+            case vpc['state']
+              when 'pending'
+                vpc['state'] = 'available'
+            end
+          end
+
+          if filters['vpc-id']
+            vpcs = vpcs.reject {|vpc| vpc['vpcId'] != filters['vpc-id']}
+          end
+
+          vpcs.each do |vpc|
+            tags = self.data[:tag_sets][vpc['vpcId']]
+            vpc.merge!('tagSet' => tags) if tags
+          end
+
+          Excon::Response.new(
+            :status => 200,
+            :body   => {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'vpcSet'    => vpcs
+            }
+          )
+        end
+      end
+    end
+  end
+end