fog 0.11.0 → 1.0.0

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

@@ -1,133 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-
-        require 'fog/compute/parsers/aws/describe_images'
-
-        # Describe all or specified images.
-        #
-        # ==== Params
-        # * filters<~Hash> - List of filters to limit results with
-        #   * filters and/or the following
-        #   * 'ExecutableBy'<~String> - Only return images that the executable_by
-        #     user has explicit permission to launch
-        #   * 'ImageId'<~Array> - Ids of images to describe
-        #   * 'Owner'<~String> - Only return images belonging to owner.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'imagesSet'<~Array>:
-        #       * 'architecture'<~String> - Architecture of the image
-        #       * 'blockDeviceMapping'<~Array> - An array of mapped block devices
-        #       * 'description'<~String> - Description of image
-        #       * 'imageId'<~String> - Id of the image
-        #       * 'imageLocation'<~String> - Location of the image
-        #       * 'imageOwnerAlias'<~String> - Alias of the owner of the image
-        #       * 'imageOwnerId'<~String> - Id of the owner of the image
-        #       * 'imageState'<~String> - State of the image
-        #       * 'imageType'<~String> - Type of the image
-        #       * 'isPublic'<~Boolean> - Whether or not the image is public
-        #       * 'kernelId'<~String> - Kernel id associated with image, if any
-        #       * 'platform'<~String> - Operating platform of the image
-        #       * 'productCodes'<~Array> - Product codes for the image
-        #       * 'ramdiskId'<~String> - Ramdisk id associated with image, if any
-        #       * 'rootDeviceName'<~String> - Root device name, e.g. /dev/sda1
-        #       * 'rootDeviceType'<~String> - Root device type, ebs or instance-store
-        #       * 'virtualizationType'<~String> - Type of virtualization
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeImages.html]
-        def describe_images(filters = {})
-          options = {}
-          for key in ['ExecutableBy', 'ImageId', 'Owner']
-            if filters.is_a?(Hash) && filters.key?(key)
-              options[key] = filters.delete(key)
-            end
-          end
-          params = Fog::AWS.indexed_filters(filters).merge!(options)
-          request({
-            'Action'    => 'DescribeImages',
-            :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::DescribeImages.new
-          }.merge!(params))
-        end
-
-      end
-
-      class Mock
-
-        def describe_images(filters = {})
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] describe_images with #{filters.class} param is deprecated, use describe_images('image-id' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'image-id' => [*filters]}
-          end
-
-          if filters.keys.any? {|key| key =~ /^block-device/}
-            Formatador.display_line("[yellow][WARN] describe_images block-device-mapping filters are not yet mocked[/] [light_black](#{caller.first})[/]")
-            Fog::Mock.not_implemented
-          end
-
-          if owner = filters.delete('Owner')
-            if owner == 'self'
-              filters['owner-id'] = self.data[:owner_id]
-            else
-              filters['owner-alias'] = owner
-            end
-          end
-
-          response = Excon::Response.new
-
-          aliases = {
-            'architecture'        => 'architecture',
-            'description'         => 'description',
-            'hypervisor'          => 'hypervisor',
-            'image-id'            => 'imageId',
-            'image-type'          => 'imageType',
-            'is-public'           => 'isPublic',
-            'kernel-id'           => 'kernelId',
-            'manifest-location'   => 'manifestLocation',
-            'name'                => 'name',
-            'owner-alias'         => 'imageOwnerAlias',
-            'owner-id'            => 'imageOwnerId',
-            'ramdisk-id'          => 'ramdiskId',
-            'root-device-name'    => 'rootDeviceName',
-            'root-device-type'    => 'rootDeviceType',
-            'state'               => 'imageState',
-            'virtualization-type' => 'virtualizationType'
-          }
-
-          image_set = self.data[:images].values
-
-          for filter_key, filter_value in filters
-            if tag_key = filter_key.split('tag:')[1]
-              image_set = image_set.reject{|image| ![*filter_value].include?(image['tagSet'][tag_key])}
-            else
-              aliased_key = aliases[filter_key]
-              image_set = image_set.reject{|image| ![*filter_value].include?(image[aliased_key])}
-            end
-          end
-
-          image_set = image_set.map do |image|
-            case image['imageState']
-            when 'pending'
-              if Time.now - image['registered'] >= Fog::Mock.delay
-                image['imageState'] = 'available'
-              end
-            end
-            image.reject { |key, value| ['registered'].include?(key) }
-          end
-
-          response.status = 200
-          response.body = {
-            'requestId' => Fog::AWS::Mock.request_id,
-            'imagesSet' => image_set
-          }
-          response
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,204 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-
-        require 'fog/compute/parsers/aws/describe_instances'
-
-        # Describe all or specified instances
-        #
-        # ==== Parameters
-        # * filters<~Hash> - List of filters to limit results with
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'reservationSet'<~Array>:
-        #       * 'groupSet'<~Array> - Group names for reservation
-        #       * 'ownerId'<~String> - AWS Access Key ID of reservation owner
-        #       * 'reservationId'<~String> - Id of the reservation
-        #       * 'instancesSet'<~Array>:
-        #         * instance<~Hash>:
-        #           * 'architecture'<~String> - architecture of image in [i386, x86_64]
-        #           * 'amiLaunchIndex'<~Integer> - reference to instance in launch group
-        #           * 'blockDeviceMapping'<~Array>
-        #             * 'attachTime'<~Time> - time of volume attachment
-        #             * 'deleteOnTermination'<~Boolean> - whether or not to delete volume on termination
-        #             * 'deviceName'<~String> - specifies how volume is exposed to instance
-        #             * 'status'<~String> - status of attached volume
-        #             * 'volumeId'<~String> - Id of attached volume
-        #           * 'dnsName'<~String> - public dns name, blank until instance is running
-        #           * 'imageId'<~String> - image id of ami used to launch instance
-        #           * 'instanceId'<~String> - id of the instance
-        #           * 'instanceState'<~Hash>:
-        #             * 'code'<~Integer> - current status code
-        #             * 'name'<~String> - current status name
-        #           * 'instanceType'<~String> - type of instance
-        #           * 'ipAddress'<~String> - public ip address assigned to instance
-        #           * 'kernelId'<~String> - id of kernel used to launch instance
-        #           * 'keyName'<~String> - name of key used launch instances or blank
-        #           * 'launchTime'<~Time> - time instance was launched
-        #           * 'monitoring'<~Hash>:
-        #             * 'state'<~Boolean - state of monitoring
-        #           * 'placement'<~Hash>:
-        #             * 'availabilityZone'<~String> - Availability zone of the instance
-        #           * 'productCodes'<~Array> - Product codes for the instance
-        #           * 'privateDnsName'<~String> - private dns name, blank until instance is running
-        #           * 'privateIpAddress'<~String> - private ip address assigned to instance
-        #           * 'rootDeviceName'<~String> - specifies how the root device is exposed to the instance
-        #           * 'rootDeviceType'<~String> - root device type used by AMI in [ebs, instance-store]
-        #           * 'ramdiskId'<~String> - Id of ramdisk used to launch instance
-        #           * 'reason'<~String> - reason for most recent state transition, or blank
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeInstances.html]
-        def describe_instances(filters = {})
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] describe_instances with #{filters.class} param is deprecated, use describe_instances('instance-id' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'instance-id' => [*filters]}
-          end
-          params = {}
-          # when seeking single instance id, old param style provides more accurate data sooner
-          if filters['instance-id'] && !filters['instance-id'].is_a?(Array)
-            params.merge!('InstanceId' => filters.delete('instance-id'))
-          end
-          params.merge!(Fog::AWS.indexed_filters(filters))
-
-          request({
-            'Action'    => 'DescribeInstances',
-            :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::DescribeInstances.new
-          }.merge!(params))
-        end
-
-      end
-
-      class Mock
-
-        def describe_instances(filters = {})
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] describe_instances with #{filters.class} param is deprecated, use describe_instances('instance-id' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'instance-id' => [*filters]}
-          end
-
-          response = Excon::Response.new
-
-          instance_set = self.data[:instances].values
-          instance_set = apply_tag_filters(instance_set, filters)
-          
-          aliases = {
-            'architecture'      => 'architecture',
-            'availability-zone' => 'availabilityZone',
-            'client-token'      => 'clientToken',
-            'dns-name'         => 'dnsName',
-            'group-id'          => 'groupId',
-            'image-id'          => 'imageId',
-            'instance-id'       => 'instanceId',
-            'instance-lifecycle'  => 'instanceLifecycle',
-            'instance-type'     => 'instanceType',
-            'ip-address'        => 'ipAddress',
-            'kernel-id'         => 'kernelId',
-            'key-name'          => 'key-name',
-            'launch-index'      => 'launchIndex',
-            'launch-time'       => 'launchTime',
-            'monitoring-state'  => 'monitoringState',
-            'owner-id'          => 'ownerId',
-            'placement-group-name' => 'placementGroupName',
-            'platform'          => 'platform',
-            'private-dns-name'  => 'privateDnsName',
-            'private-ip-address'  => 'privateIpAddress',
-            'product-code'      => 'productCode',
-            'ramdisk-id'        => 'ramdiskId',
-            'reason'            => 'reason',
-            'requester-id'      => 'requesterId',
-            'reservation-id'    => 'reservationId',
-            'root-device-name'  => 'rootDeviceName',
-            'root-device-type'  => 'rootDeviceType',
-            'spot-instance-request-id' => 'spotInstanceRequestId',
-            'subnet-id'         => 'subnetId',
-            'virtualization-type' => 'virtualizationType',
-            'vpc-id'            => 'vpcId'
-          }
-          block_device_mapping_aliases = {
-            'attach-time'           => 'attachTime',
-            'delete-on-termination' => 'deleteOnTermination',
-            'device-name'           => 'deviceName',
-            'status'                => 'status',
-            'volume-id'             => 'volumeId',
-          }
-          instance_state_aliases = {
-            'code' => 'code',
-            'name' => 'name'
-          }
-          state_reason_aliases = {
-            'code'    => 'code',
-            'message' => 'message'
-          }
-          for filter_key, filter_value in filters
-            if block_device_mapping_key = filter_key.split('block-device-mapping.')[1]
-              aliased_key = block_device_mapping_aliases[block_device_mapping_key]
-              instance_set = instance_set.reject{|instance| !instance['blockDeviceMapping'].detect {|block_device_mapping| [*filter_value].include?(block_device_mapping[aliased_key])}}
-            elsif instance_state_key = filter_key.split('instance-state-')[1]
-              aliased_key = instance_state_aliases[instance_state_key]
-              instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['instanceState'][aliased_key])}
-            elsif state_reason_key = filter_key.split('state-reason-')[1]
-              aliased_key = state_reason_aliases[state_reason_key]
-              instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['stateReason'][aliased_key])}
-            else
-              aliased_key = aliases[filter_key]
-              instance_set = instance_set.reject {|instance| ![*filter_value].include?(instance[aliased_key])}
-            end
-          end
-
-          response.status = 200
-          reservation_set = {}
-
-          instance_set.each do |instance|
-            case instance['instanceState']['name']
-            when 'pending'
-              if Time.now - instance['launchTime'] >= Fog::Mock.delay
-                instance['ipAddress']         = Fog::AWS::Mock.ip_address
-                instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
-                instance['privateIpAddress']  = Fog::AWS::Mock.ip_address
-                instance['privateDnsName']    = Fog::AWS::Mock.private_dns_name_for(instance['privateIpAddress'])
-                instance['instanceState']     = { 'code' => 16, 'name' => 'running' }
-              end
-            when 'rebooting'
-              instance['instanceState'] = { 'code' => 16, 'name' => 'running' }
-            when 'shutting-down'
-              if Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay * 2
-                self.data[:deleted_at].delete(instance['instanceId'])
-                self.data[:instances].delete(instance['instanceId'])
-              elsif Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay
-                instance['instanceState'] = { 'code' => 48, 'name' => 'terminating' }
-              end
-            when 'terminating'
-              if Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay
-                self.data[:deleted_at].delete(instance['instanceId'])
-                self.data[:instances].delete(instance['instanceId'])
-              end
-            end
-
-            if self.data[:instances][instance['instanceId']]
-
-              reservation_set[instance['reservationId']] ||= {
-                'groupSet'      => instance['groupSet'],
-                'instancesSet'  => [],
-                'ownerId'       => instance['ownerId'],
-                'reservationId' => instance['reservationId']
-              }
-              reservation_set[instance['reservationId']]['instancesSet'] << instance.reject{|key,value| !['amiLaunchIndex', 'architecture', 'blockDeviceMapping', 'clientToken', 'dnsName', 'imageId', 'instanceId', 'instanceState', 'instanceType', 'ipAddress', 'kernelId', 'keyName', 'launchTime', 'monitoring', 'placement', 'privateDnsName', 'privateIpAddress', 'productCodes', 'ramdiskId', 'reason', 'rootDeviceType', 'stateReason', 'tagSet'].include?(key)}
-            end
-          end
-
-          response.body = {
-            'requestId'       => Fog::AWS::Mock.request_id,
-            'reservationSet' => reservation_set.values
-          }
-          response
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-
-        require 'fog/compute/parsers/aws/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)
-            Formatador.display_line("[yellow][WARN] 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)
-            Formatador.display_line("[yellow][WARN] 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/compute/requests/aws/describe_placement_groups.rb

@@ -1,35 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-
-        require 'fog/compute/parsers/aws/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/compute/requests/aws/describe_regions.rb

@@ -1,68 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-
-        require 'fog/compute/parsers/aws/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)
-            Formatador.display_line("[yellow][WARN] 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)
-            Formatador.display_line("[yellow][WARN] 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