fog 0.0.3

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

@@ -0,0 +1,114 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Describe all or specified instances
+        #
+        # ==== Parameters
+        # * instance_id<~Array> - List of instance ids to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::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>:
+        #           * 'amiLaunchIndex'<~Integer> - reference to instance in launch group
+        #           * '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
+        #           * '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
+        #           * '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 = indexed_params('InstanceId', instance_id)
+          request({
+            'Action' => 'DescribeInstances'
+          }.merge!(params), Fog::Parsers::AWS::EC2::DescribeInstances.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def describe_instances(instance_id = {})
+          response = Fog::Response.new
+          instance_id = [*instance_id]
+          if instance_id != []
+            instance_set = Fog::AWS::EC2.data[:instances].reject {|key,value| !instance_id.include?(key)}.values
+          else
+            instance_set = Fog::AWS::EC2.data[:instances].values
+          end
+
+          instance_set.each do |instance|
+            case instance['instanceState']
+            when 'pending'
+              if Time.now - instance['launchTime'] > 2
+                instance['instanceState'] = { :code => 16, :name => 'running' }
+              end
+            when 'shutting-down'
+              if Time.now - Fog::AWS::EC2.data[:deleted_at][instance['instanceId']] > 2
+                instance['instanceState'] = { :code => 16, :name => 'terminating' }
+              end
+            when 'terminating'
+              if Time.now - Fog::AWS::EC2.data[:deleted_at][instance['instanceId']] > 4
+                Fog::AWS::EC2.data[:deleted_at].delete(instance['instanceId'])
+                Fog::AWS::EC2.data[:instances].delete(instance['instanceId'])
+              end
+            end
+          end
+
+          if instance_id.length == 0 || instance_id.length == instance_set.length
+            response.status = 200
+
+            reservation_set = {}
+            instance_set.each do |instance|
+              reservation_set[instance['reservationId']] ||= {
+                'groupSet'      => instance['groupSet'],
+                'instancesSet'  => [],
+                'ownerId'       => instance['ownerId'],
+                'reservationId' => instance['reservationId']
+              }
+              reservation_set[instance['reservationId']]['instancesSet'] << instance.reject{|key,value| !['amiLaunchIndex', 'dnsName', 'imageId', 'instanceId', 'instanceState', 'instanceType', 'kernelId', 'keyName', 'launchTime', 'monitoring', 'placement', 'privateDnsName', 'productCodes', 'ramdiskId', 'reason'].include?(key)}
+            end
+
+            response.body = {
+              'requestId'       => Fog::AWS::Mock.request_id,
+              'reservationSet' => reservation_set.values
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,63 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Describe all or specified key pairs
+        #
+        # ==== Parameters
+        # * key_name<~Array>:: List of key names to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::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 = indexed_params('KeyName', key_name)
+          request({
+            'Action' => 'DescribeKeyPairs'
+          }.merge!(params), Fog::Parsers::AWS::EC2::DescribeKeyPairs.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def describe_key_pairs(key_name = [])
+          response = Fog::Response.new
+          key_name = [*key_name]
+          if key_name != []
+            key_set = Fog::AWS::EC2.data[:key_pairs].reject {|key, value| !key_name.include?(key)}.values
+          else
+            key_set = Fog::AWS::EC2.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
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,61 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Describe all or specified regions
+        #
+        # ==== Params
+        # * region_name<~String> - List of regions to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::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 = indexed_params('RegionName', region_name)
+          request({
+            'Action' => 'DescribeRegions'
+          }.merge!(params), Fog::Parsers::AWS::EC2::DescribeRegions.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def describe_regions(region_name = [])
+          response = Fog::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
+
+          response.status = 200
+          response.body = {
+            'requestId'   => Fog::AWS::Mock.request_id,
+            'regionInfo'  => region_info
+          }
+          response
+        end
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,71 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Describe all or specified security groups
+        #
+        # ==== Parameters
+        # * group_name<~Array> - List of groups to describe, defaults to all
+        #
+        # === Returns
+        # * response<~Fog::AWS::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 = indexed_params('GroupName', group_name)
+          request({
+            'Action' => 'DescribeSecurityGroups',
+          }.merge!(params), Fog::Parsers::AWS::EC2::DescribeSecurityGroups.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def describe_security_groups(group_name = [])
+          response = Fog::Response.new
+          group_name = [*group_name]
+          if group_name != []
+            security_group_info = Fog::AWS::EC2.data[:security_groups].reject {|key, value| !group_name.include?(key)}.values
+          else
+            security_group_info = Fog::AWS::EC2.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
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,78 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+      
+        # Describe all or specified snapshots
+        #
+        # ==== Parameters
+        # * snapshot_id<~Array> - List of snapshots to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::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 = [])
+          params = indexed_params('SnapshotId', snapshot_id)
+          request({
+            'Action' => 'DescribeSnapshots'
+          }.merge!(params), Fog::Parsers::AWS::EC2::DescribeSnapshots.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def describe_snapshots(snapshot_id = [])
+          response = Fog::Response.new
+          snapshot_id = [*snapshot_id]
+          if snapshot_id != []
+            snapshot_set = Fog::AWS::EC2.data[:snapshots].reject {|key,value| !snapshot_id.include?(key)}.values
+          else
+            snapshot_set = Fog::AWS::EC2.data[:snapshots].values
+          end
+
+          snapshot_set.each do |snapshot|
+            case snapshot['status']
+            when 'creating'
+              if Time.now - volume['createTime'] > 2
+                snapshot['progress']  = '100%'
+                snapshot['status']    = 'completed'
+              else
+                snapshot['progress']  = '50%'
+                snapshot['status']    = 'in progress'
+              end
+            end
+          end
+
+          if snapshot_id.length == 0 || snapshot_id.length == snapshot_set.length
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'snapshotSet' => snapshot_set
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,85 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Describe all or specified volumes.
+        #
+        # ==== Parameters
+        # * volume_id<~Array> - List of volumes to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'volumeSet'<~Array>:
+        #       * 'availabilityZone'<~String> - Availability zone for volume
+        #       * 'createTime'<~Time> - Timestamp for creation
+        #       * '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
+        #       * 'attachmentSet'<~Array>:
+        #         * 'attachmentTime'<~Time> - Timestamp for attachment
+        #         * 'device'<~String> - How value is exposed to instance
+        #         * 'instanceId'<~String> - Reference to attached instance
+        #         * 'status'<~String> - Attachment state
+        #         * 'volumeId'<~String> - Reference to volume
+        def describe_volumes(volume_id = [])
+          params = indexed_params('VolumeId', volume_id)
+          request({
+            'Action' => 'DescribeVolumes'
+          }.merge!(params), Fog::Parsers::AWS::EC2::DescribeVolumes.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def describe_volumes(volume_id = [])
+          response = Fog::Response.new
+          volume_id = [*volume_id]
+          if volume_id != []
+            volume_set = Fog::AWS::EC2.data[:volumes].reject {|key,value| !volume_id.include?(key)}.values
+          else
+            volume_set = Fog::AWS::EC2.data[:volumes].values
+          end
+
+          volume_set.each do |volume|
+            case volume['status']
+            when 'creating'
+              if Time.now - volume['createTime'] > 2
+                volume['status'] = 'available'
+              end
+            when 'deleting'
+              if Time.now - Fog::AWS::EC2.data[:deleted_at][volume['volumeId']] > 2
+                Fog::AWS::EC2.data[:deleted_at].delete(volume['volumeId'])
+                Fog::AWS::EC2.data[:volumes].delete(volume['volumeId'])
+              end
+            end
+          end
+
+          if volume_id.length == 0 || volume_id.length == volume_set.length
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'volumeSet' => volume_set
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end