fog-aws 0.0.5

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

@@ -0,0 +1,126 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/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.merge!(Fog::AWS.indexed_request_param(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)
+            Fog::Logger.deprecation("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/}
+            Fog::Logger.warning("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 = visible_images.values
+          image_set = apply_tag_filters(image_set, filters, 'imageId')
+
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            image_set = image_set.reject{|image| ![*filter_value].include?(image[aliased_key])}
+          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) }.merge('tagSet' => self.data[:tag_sets][image['imageId']])
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'imagesSet' => image_set
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        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')
+          all_instances = filters.delete('includeAllInstances') || filters.delete('IncludeAllInstances')
+
+          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['IncludeAllInstances'] = all_instances if all_instances
+
+          request({
+            'Action'    => 'DescribeInstanceStatus',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeInstanceStatus.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_instance_status(filters = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'instanceStatusSet' => [],
+            'requestId' => Fog::AWS::Mock.request_id
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,265 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/describe_instances'
+
+        # Describe all or specified instances
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #   * Also allows for passing of optional parameters to fetch instances in batches:
+        #     * 'maxResults' - The number of instances to return for the request
+        #     * 'nextToken' - The token to fetch the next set of items. This is returned by a previous request.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'nextToken' - The token to use when requesting the next set of items when fetching items in batches.
+        #     * '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
+        #           * 'ebsOptimized'<~Boolean> - Whether the instance is optimized for EBS I/O
+        #           * '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
+        #           * 'platform'<~String> - Platform of the instance (e.g., Windows).
+        #           * '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)
+            Fog::Logger.deprecation("describe_instances with #{filters.class} param is deprecated, use describe_instances('instance-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'instance-id' => [*filters]}
+          end
+          params = {}
+
+          next_token  = filters.delete('nextToken') || filters.delete('NextToken')
+          max_results = filters.delete('maxResults') || filters.delete('MaxResults')
+
+          if filters['instance-id']
+            instance_ids = filters.delete('instance-id')
+            instance_ids = [instance_ids] unless instance_ids.is_a?(Array)
+            instance_ids.each_with_index do |id, index|
+              params.merge!("InstanceId.#{index}" => id)
+            end
+          end
+
+          params['NextToken']  = next_token if next_token
+          params['MaxResults'] = max_results if max_results
+          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)
+            Fog::Logger.deprecation("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, 'instanceId')
+
+          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'].find {|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])}
+            elsif filter_key == "availability-zone"
+              aliased_key = aliases[filter_key]
+              instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['placement'][aliased_key])}
+            elsif filter_key == "group-name"
+              instance_set = instance_set.reject {|instance| !instance['groupSet'].include?(filter_value)}
+            elsif filter_key == "group-id"
+              group_ids = [*filter_value]
+              security_group_names = self.data[:security_groups].values.select { |sg| group_ids.include?(sg['groupId']) }.map { |sg| sg['groupName'] }
+              instance_set = instance_set.reject {|instance| (security_group_names & instance['groupSet']).empty?}
+            else
+              aliased_key = aliases[filter_key]
+              instance_set = instance_set.reject {|instance| ![*filter_value].include?(instance[aliased_key])}
+            end
+          end
+
+          brand_new_instances = instance_set.select do |instance|
+            instance['instanceState']['name'] == 'pending' &&
+              Time.now - instance['launchTime'] < Fog::Mock.delay * 2
+          end
+
+          # Error if filtering for a brand new instance directly
+          if (filters['instance-id'] || filters['instanceId']) && !brand_new_instances.empty?
+            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{brand_new_instances.first['instanceId']}' does not exist")
+          end
+
+          # Otherwise don't include it in the list
+          instance_set = instance_set.reject {|instance| brand_new_instances.include?(instance) }
+
+          response.status = 200
+          reservation_set = {}
+
+          instance_set.each do |instance|
+            case instance['instanceState']['name']
+            when 'pending'
+              if Time.now - instance['launchTime'] >= Fog::Mock.delay * 2
+                instance['ipAddress']         = Fog::AWS::Mock.ip_address
+                instance['originalIpAddress'] = instance['ipAddress']
+                instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
+                instance['instanceState']     = { 'code' => 16, 'name' => 'running' }
+              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'])
+                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']]
+
+              nics = self.data[:network_interfaces].select{|ni,ni_conf|
+                ni_conf['attachment']['instanceId'] == instance['instanceId']
+              }
+              instance['networkInterfaces'] = nics.map{|ni,ni_conf|
+                {
+                  'ownerId' => ni_conf['ownerId'],
+                  'subnetId' => ni_conf['subnetId'],
+                  'vpcId' => ni_conf['vpcId'],
+                  'networkInterfaceId' => ni_conf['networkInterfaceId'],
+                  'groupSet' => ni_conf['groupSet'],
+                  'attachmentId' => ni_conf['attachment']['attachmentId']
+                }
+              }
+              if nics.count > 0
+
+                instance['privateIpAddress'] = nics.sort_by {|ni, ni_conf|
+                  ni_conf['attachment']['deviceIndex']
+                }.map{ |ni, ni_conf| ni_conf['privateIpAddress'] }.first
+
+                instance['privateDnsName'] = Fog::AWS::Mock.private_dns_name_for(instance['privateIpAddress'])
+              else
+                instance['privateIpAddress'] = ''
+                instance['privateDnsName'] = ''
+              end
+
+              reservation_set[instance['reservationId']] ||= {
+                'groupSet'      => instance['groupSet'],
+                'groupIds'      => instance['groupIds'],
+                'instancesSet'  => [],
+                'ownerId'       => instance['ownerId'],
+                'reservationId' => instance['reservationId']
+              }
+              reservation_set[instance['reservationId']]['instancesSet'] << instance.reject{|key,value| !['amiLaunchIndex', 'architecture', 'blockDeviceMapping', 'clientToken', 'dnsName', 'ebsOptimized', 'hypervisor', 'iamInstanceProfile', 'imageId', 'instanceId', 'instanceState', 'instanceType', 'ipAddress', 'kernelId', 'keyName', 'launchTime', 'monitoring', 'networkInterfaces', 'ownerId', 'placement', 'platform', 'privateDnsName', 'privateIpAddress', 'productCodes', 'ramdiskId', 'reason', 'rootDeviceName', 'rootDeviceType', 'stateReason', 'virtualizationType'].include?(key)}.merge('tagSet' => self.data[:tag_sets][instance['instanceId']])
+            end
+          end
+
+          response.body = {
+            'requestId'       => Fog::AWS::Mock.request_id,
+            'reservationSet' => reservation_set.values
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+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 = {})
+          internet_gateways = self.data[:internet_gateways].values
+
+          if filters['internet-gateway-id']
+            internet_gateways = internet_gateways.reject {|internet_gateway| internet_gateway['internetGatewayId'] != filters['internet-gateway-id']}
+          end
+
+          Excon::Response.new(
+            :status => 200,
+            :body   => {
+              'requestId'           => Fog::AWS::Mock.request_id,
+              'internetGatewaySet'  => internet_gateways
+            }
+          )
+        end
+      end
+    end
+  end
+end