geemus-fog 0.0.0

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

@@ -0,0 +1,24 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Delete a snapshot of an EBS volume that you own
+      #
+      # ==== Parameters
+      # * snapshot_id<~String> - ID of snapshot to delete
+      # ==== Returns
+      # ==== Returns
+      # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'requestId'<~String> - Id of request
+      #     * 'return'<~Boolean> - success?
+      def delete_snapshot(snapshot_id)
+        request({
+          'Action' => 'DeleteSnapshot',
+          'SnapshotId' => snapshot_id
+        }, Fog::Parsers::AWS::EC2::Basic.new)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Delete an EBS volume
+        #
+        # ==== Parameters
+        # * volume_id<~String> - Id of volume to delete.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_volume(volume_id)
+          request({
+            'Action' => 'DeleteVolume',
+            'VolumeId' => volume_id
+          }, Fog::Parsers::AWS::EC2::Basic.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def delete_volume(volume_id)
+          response = Fog::Response.new
+          if volume = @data[:volumes][volume_id]
+            @data[:deleted_at][volume['volumeId']] = Time.now
+            volume['status'] = 'deleting'
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return' => true
+            }
+          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_addresses.rb

@@ -0,0 +1,61 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Describe all or specified IP addresses.
+        #
+        # ==== Parameters
+        # * public_ip<~Array> - List of ips to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'addressesSet'<~Array>:
+        #       * 'instanceId'<~String> - instance for ip address
+        #       * 'publicIp'<~String> - ip address for instance
+        def describe_addresses(public_ip = [])
+          params = indexed_params('PublicIp', public_ip)
+          request({
+            'Action' => 'DescribeAddresses'
+          }.merge!(params), Fog::Parsers::AWS::EC2::DescribeAddresses.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def describe_addresses(public_ip = [])
+          public_ip = [*public_ip]
+          response = Fog::Response.new
+          if public_ip != []
+            addresses_set = @data[:addresses].reject {|key, value| !public_ip.include?(key)}.values
+          else
+            addresses_set = @data[:addresses].values
+          end
+          if public_ip.length == 0 || public_ip.length == addresses_set.length
+            response.status = 200
+            response.body = {
+              'requestId'     => Fog::AWS::Mock.request_id,
+              'addressesSet'  => addresses_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_availability_zones.rb

@@ -0,0 +1,27 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Describe all or specified availability zones
+      #
+      # ==== Params
+      # * zone_name<~String> - List of availability zones to describe, defaults to all
+      #
+      # ==== Returns
+      # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'requestId'<~String> - Id of request
+      #     * 'availabilityZoneInfo'<~Array>:
+      #       * 'regionName'<~String> - Name of region
+      #       * 'zoneName'<~String> - Name of zone
+      #       * 'zoneState'<~String> - State of zone
+      def describe_availability_zones(zone_name = [])
+        params = indexed_params('ZoneName', zone_name)
+        request({
+          'Action' => 'DescribeAvailabilityZones'
+        }.merge!(params), Fog::Parsers::AWS::EC2::DescribeAvailabilityZones.new)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Fog
+  module AWS
+    class EC2
+
+      # 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<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'requestId'<~String> - Id of request
+      #     * 'imagesSet'<~Array>:
+      #       * 'architecture'<~String> - Architecture of the image
+      #       * '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
+      def describe_images(options = {})
+        if image_id = options.delete('ImageId')
+          options.merge!(indexed_params('ImageId', image_id))
+        end
+        request({
+          'Action' => 'DescribeImages'
+        }.merge!(options), Fog::Parsers::AWS::EC2::DescribeImages.new)
+      end
+
+    end
+  end
+end

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

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

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 = [])
+          key_name = [*key_name]
+          response = Fog::Response.new
+          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
+            }
+          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,26 @@
+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

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 = [])
+          group_name = [*group_name]
+          response = Fog::Response.new
+          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
+            }
+          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,29 @@
+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

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 = [])
+          volume_id = [*volume_id]
+          response = Fog::Response.new
+          if volume_id != []
+            volume_set = @data[:volumes].reject {|key,value| !volume_id.include?(key)}.values
+          else
+            volume_set = @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 - @data[:deleted_at][volume['volumeId']] > 2
+                @data[:deleted_at].delete(volume['volumeId'])
+                @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

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

@@ -0,0 +1,32 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Detach an Amazon EBS volume from a running instance
+      #
+      # ==== Parameters
+      # * volume_id<~String> - Id of amazon EBS volume to associate with instance
+      # * options<~Hash>:
+      #   * 'Device'<~String> - Specifies how the device is exposed to the instance (e.g. "/dev/sdh")
+      #   * 'Force'<~Boolean> - If true forces detach, can cause data loss/corruption
+      #   * 'InstanceId'<~String> - Id of instance to associate volume with
+      #
+      # ==== Returns
+      # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'attachTime'<~Time> - Time of attachment was initiated at
+      #     * 'device'<~String> - Device as it is exposed to the instance
+      #     * 'instanceId'<~String> - Id of instance for volume
+      #     * 'requestId'<~String> - Id of request
+      #     * 'status'<~String> - Status of volume
+      #     * 'volumeId'<~String> - Reference to volume
+      def detach_volume(volume_id, options = {})
+        request({
+          'Action' => 'DetachVolume',
+          'VolumeId' => volume_id
+        }.merge!(options), Fog::Parsers::AWS::EC2::DetachVolume.new)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Disassociate an elastic IP address from its instance (if any)
+      #
+      # ==== Parameters
+      # * public_ip<~String> - Public ip to assign to instance
+      #
+      # ==== Returns
+      # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'requestId'<~String> - Id of request
+      #     * 'return'<~Boolean> - success?
+      def disassociate_address(public_ip)
+        request({
+          'Action' => 'DisassociateAddress',
+          'PublicIp' => public_ip
+        }, Fog::Parsers::AWS::EC2::Basic.new)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Retrieve console output for specified instance
+      #
+      # ==== Parameters
+      # * instance_id<~String> - Id of instance to get console output from
+      #
+      # ==== Returns
+      # # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'instanceId'<~String> - Id of instance
+      #     * 'output'<~String> - Console output
+      #     * 'requestId'<~String> - Id of request
+      #     * 'timestamp'<~Time> - Timestamp of last update to output
+      def get_console_output(instance_id)
+        request({
+          'Action' => 'GetConsoleOutput',
+          'InstanceId' => instance_id
+        }, Fog::Parsers::AWS::EC2::GetConsoleOutput.new)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Reboot specified instances
+      #
+      # ==== Parameters
+      # * instance_id<~Array> - Ids of instances to reboot
+      #
+      # ==== Returns
+      # # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'requestId'<~String> - Id of request
+      #     * 'return'<~Boolean> - success?
+      def reboot_instances(instance_id = [])
+        params = indexed_params('InstanceId', instance_id)
+        request({
+          'Action' => 'RebootInstances'
+        }.merge!(params), Fog::Parsers::AWS::EC2::Basic.new)
+      end
+
+    end
+  end
+end