tecnh-fog 0.2.23.vpc

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

@@ -0,0 +1,70 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/describe_images'
+
+        # Describe all or specified images.
+        #
+        # ==== Params
+        # * options<~Hash> - Optional params
+        #   * '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
+        #       * 'imageId'<~String> - Id of the image
+        #       * 'imageLocation'<~String> - Location 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
+        def describe_images(options = {})
+          if image_id = options.delete('ImageId')
+            options.merge!(AWS.indexed_param('ImageId', image_id))
+          end
+          request({
+            'Action'    => 'DescribeImages',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::DescribeImages.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def describe_images(options = {})
+          response = Excon::Response.new
+          images = []
+
+          (rand(101 + 100)).times do
+            images << Fog::AWS::Mock.image
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'imagesSet' => images
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/describe_instances'
+
+        # Describe all or specified instances
+        #
+        # ==== Parameters
+        # * instance_id<~Array> - List of instance ids to describe, defaults to all
+        #
+        # ==== 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
+        def describe_instances(instance_id = [])
+          params = AWS.indexed_param('InstanceId', instance_id)
+          request({
+            'Action'    => 'DescribeInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::DescribeInstances.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_instances(instance_id = [])
+          response = Excon::Response.new
+          instance_id = [*instance_id]
+          if instance_id != []
+            instance_set = @data[:instances].reject {|key,value| !instance_id.include?(key)}.values
+          else
+            instance_set = @data[:instances].values
+          end
+
+          if instance_id.length == 0 || instance_id.length == instance_set.length
+            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 - @data[:deleted_at][instance['instanceId']] > Fog::Mock.delay * 2
+                  @data[:deleted_at].delete(instance['instanceId'])
+                  @data[:instances].delete(instance['instanceId'])
+                elsif Time.now - @data[:deleted_at][instance['instanceId']] > Fog::Mock.delay
+                  instance['instanceState'] = { 'code' => 48, 'name' => 'terminating' }
+                end
+              when 'terminating'
+                if Time.now - @data[:deleted_at][instance['instanceId']] > Fog::Mock.delay
+                  @data[:deleted_at].delete(instance['instanceId'])
+                  @data[:instances].delete(instance['instanceId'])
+                end
+              end
+
+              if @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', 'dnsName', 'imageId', 'instanceId', 'instanceState', 'instanceType', 'ipAddress', 'kernelId', 'keyName', 'launchTime', 'monitoring', 'placement', 'privateDnsName', 'privateIpAddress', 'productCodes', 'ramdiskId', 'reason', 'rootDeviceType'].include?(key)}
+              end
+            end
+
+            response.body = {
+              'requestId'       => Fog::AWS::Mock.request_id,
+              'reservationSet' => reservation_set.values
+            }
+            response
+          else
+            raise Fog::AWS::EC2::NotFound.new("The instance ID #{instance_id.inspect} does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/describe_key_pairs'
+
+        # Describe all or specified key pairs
+        #
+        # ==== Parameters
+        # * key_name<~Array>:: List of key names to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'keySet'<~Array>:
+        #       * 'keyName'<~String> - Name of key
+        #       * 'keyFingerprint'<~String> - Fingerprint of key
+        def describe_key_pairs(key_name = [])
+          params = AWS.indexed_param('KeyName', key_name)
+          request({
+            'Action'    => 'DescribeKeyPairs',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::DescribeKeyPairs.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_key_pairs(key_name = [])
+          response = Excon::Response.new
+          key_name = [*key_name]
+          if key_name != []
+            key_set = @data[:key_pairs].reject {|key, value| !key_name.include?(key)}.values
+          else
+            key_set = @data[:key_pairs].values
+          end
+          if key_name.length == 0 || key_name.length == key_set.length
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'keySet'    => key_set.map do |key|
+                key.reject {|key,value| !['keyFingerprint', 'keyName'].include?(key)}
+              end
+            }
+            response
+          else
+            raise Fog::AWS::EC2::NotFound.new("The key pair #{key_name.inspect} does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/describe_regions'
+
+        # Describe all or specified regions
+        #
+        # ==== Params
+        # * region_name<~String> - List of regions to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'regionInfo'<~Array>:
+        #       * 'regionName'<~String> - Name of region
+        #       * 'regionEndpoint'<~String> - Service endpoint for region
+        def describe_regions(region_name = [])
+          params = AWS.indexed_param('RegionName', region_name)
+          request({
+            'Action'    => 'DescribeRegions',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::DescribeRegions.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_regions(region_name = [])
+          response = Excon::Response.new
+          region_name = [*region_name]
+          regions = {
+            'eu-west-1' => {"regionName"=>"eu-west-1", "regionEndpoint"=>"eu-west-1.ec2.amazonaws.com"},
+            'us-east-1' => {"regionName"=>"us-east-1", "regionEndpoint"=>"us-east-1.ec2.amazonaws.com"}
+          }
+          if region_name != []
+            region_info = regions.reject {|key, value| !region_name.include?(key)}.values
+          else
+            region_info = regions.values
+          end
+
+          if region_name.length == 0 || region_name.length == region_info.length
+            response.status = 200
+            response.body = {
+              'requestId'   => Fog::AWS::Mock.request_id,
+              'regionInfo'  => region_info
+            }
+            response
+          else
+            raise Fog::AWS::EC2::Error.new("InvalidParameterValue => Invalid region: #{region_name.inspect}")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/describe_reserved_instances'
+
+        # Describe all or specified reserved instances
+        #
+        # ==== Parameters
+        # * reserved_instances_id<~Array> - List of reserved instance ids to describe, defaults to all
+        #
+        # ==== 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
+        def describe_reserved_instances(reserved_instances_id = [])
+          params = AWS.indexed_param('ReservedInstancesId', reserved_instances_id)
+          request({
+            'Action'    => 'DescribeReservedInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::DescribeReservedInstances.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_reserved_instances(reserved_instances_id = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ec2/describe_security_groups.rb

@@ -0,0 +1,66 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/describe_security_groups'
+
+        # Describe all or specified security groups
+        #
+        # ==== Parameters
+        # * group_name<~Array> - List of groups to describe, defaults to all
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'securityGroupInfo'<~Array>:
+        #       * 'groupDescription'<~String> - Description of security group
+        #       * 'groupName'<~String> - Name of security group
+        #       * 'ipPermissions'<~Array>:
+        #         * 'fromPort'<~Integer> - Start of port range (or -1 for ICMP wildcard)
+        #         * 'groups'<~Array>:
+        #           * 'groupName'<~String> - Name of security group
+        #           * 'userId'<~String> - AWS User Id of account
+        #         * 'ipProtocol'<~String> - Ip protocol, must be in ['tcp', 'udp', 'icmp']
+        #         * 'ipRanges'<~Array>:
+        #           * 'cidrIp'<~String> - CIDR range
+        #         * 'toPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
+        #       * 'ownerId'<~String> - AWS Access Key Id of the owner of the security group
+        def describe_security_groups(group_name = [])
+          params = AWS.indexed_param('GroupName', group_name)
+          request({
+            'Action'    => 'DescribeSecurityGroups',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::DescribeSecurityGroups.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_security_groups(group_name = [])
+          response = Excon::Response.new
+          group_name = [*group_name]
+          if group_name != []
+            security_group_info = @data[:security_groups].reject {|key, value| !group_name.include?(key)}.values
+          else
+            security_group_info = @data[:security_groups].values
+          end
+          if group_name.length == 0 || group_name.length == security_group_info.length
+            response.status = 200
+            response.body = {
+              'requestId'         => Fog::AWS::Mock.request_id,
+              'securityGroupInfo' => security_group_info
+            }
+            response
+          else
+            raise Fog::AWS::EC2::NotFound.new("The security group #{group_name.inspect} does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ec2/describe_snapshots.rb

@@ -0,0 +1,80 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/describe_snapshots'
+
+        # Describe all or specified snapshots
+        #
+        # ==== Parameters
+        # * snapshot_id<~Array> - List of snapshots to describe, defaults to all
+        # * options<~Array>:
+        #   * 'Owner'<~String> - Owner of snapshot in ['self', 'amazon', account_id]
+        #   * 'RestorableBy'<~String> - Account id of user who can create volumes from this snapshot
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'snapshotSet'<~Array>:
+        #       * 'progress'<~String>: The percentage progress of the snapshot
+        #       * 'snapshotId'<~String>: Id of the snapshot
+        #       * 'startTime'<~Time>: Timestamp of when snapshot was initiated
+        #       * 'status'<~String>: Snapshot state, in ['pending', 'completed']
+        #       * 'volumeId'<~String>: Id of volume that snapshot contains
+        def describe_snapshots(snapshot_id = [], options = {})
+          options['Owner'] ||= 'self'
+          options.merge!(AWS.indexed_param('SnapshotId', snapshot_id))
+          request({
+            'Action'    => 'DescribeSnapshots',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::DescribeSnapshots.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def describe_snapshots(snapshot_id = [])
+          response = Excon::Response.new
+          snapshot_id = [*snapshot_id]
+          if snapshot_id != []
+            snapshot_set = @data[:snapshots].reject {|key,value| !snapshot_id.include?(key)}.values
+          else
+            snapshot_set = @data[:snapshots].values
+          end
+
+          if snapshot_id.length == 0 || snapshot_id.length == snapshot_set.length
+            snapshot_set.each do |snapshot|
+              case snapshot['status']
+              when 'in progress', 'pending'
+                if Time.now - snapshot['startTime'] > Fog::Mock.delay * 2
+                  snapshot['progress']  = '100%'
+                  snapshot['status']    = 'completed'
+                elsif Time.now - snapshot['startTime'] > Fog::Mock.delay
+                  snapshot['progress']  = '50%'
+                  snapshot['status']    = 'in progress'
+                else
+                  snapshot['progress']  = '0%'
+                  snapshot['status']    = 'in progress'
+                end
+              end
+            end
+
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'snapshotSet' => snapshot_set
+            }
+            response
+          else
+            raise Fog::AWS::EC2::NotFound.new("The snapshot #{snapshot_id.inspect} does not exist.")
+          end
+        end
+
+      end
+    end
+  end
+end