fog 1.26.0 → 1.27.0

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

@@ -1,35 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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