fog 0.0.3

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

@@ -0,0 +1,66 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Create an EBS volume
+        #
+        # ==== Parameters
+        # * availability_zone<~String> - availability zone to create volume in
+        # * size<~Integer> - Size in GiBs for volume.  Must be between 1 and 1024.
+        # * snapshot_id<~String> - Optional, snapshot to create volume from
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * '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's<~String> - State of volume
+        #     * 'volumeId'<~String> - Reference to volume
+        def create_volume(availability_zone, size, snapshot_id = nil)
+          request({
+            'Action' => 'CreateVolume',
+            'AvailabilityZone' => availability_zone,
+            'Size' => size,
+            'SnapshotId' => snapshot_id
+          }, Fog::Parsers::AWS::EC2::CreateVolume.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def create_volume(availability_zone, size, snapshot_id = nil)
+          response = Fog::Response.new
+          response.status = 200
+          volume_id = Fog::AWS::Mock.volume_id
+          data = {
+            'availabilityZone'  => availability_zone,
+            'attachmentSet'     => [],
+            'createTime'        => Time.now,
+            'size'              => size,
+            'snapshotId'        => snapshot_id || '',
+            'status'            => 'creating',
+            'volumeId'          => volume_id
+          }
+          Fog::AWS::EC2.data[:volumes][volume_id] = data
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id
+          }.merge!(data.reject {|key,value| !['availabilityZone','createTime','size','snapshotId','status','volumeId'].include?(key) })
+          response
+        end
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,49 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Delete a key pair that you own
+        #
+        # ==== Parameters
+        # * key_name<~String> - Name of the key pair.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_key_pair(key_name)
+          request({
+            'Action' => 'DeleteKeyPair',
+            'KeyName' => key_name
+          }, Fog::Parsers::AWS::EC2::Basic.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def delete_key_pair(key_name)
+          response = Fog::Response.new
+          Fog::AWS::EC2.data[:key_pairs].delete(key_name)
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
+        end
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,52 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Delete a security group that you own
+        #
+        # ==== Parameters
+        # * group_name<~String> - Name of the security group.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_security_group(name)
+          request({
+            'Action' => 'DeleteSecurityGroup',
+            'GroupName' => name
+          }, Fog::Parsers::AWS::EC2::Basic.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+        def delete_security_group(name)
+          response = Fog::Response.new
+          if Fog::AWS::EC2.data[:security_groups][name]
+            Fog::AWS::EC2.data[:security_groups].delete(name)
+            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/delete_snapshot.rb

@@ -0,0 +1,53 @@
+unless Fog.mocking?
+
+  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
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def delete_snapshot(snapshot_id)
+          response = Fog::Response.new
+          if snapshot = Fog::AWS::EC2.data[:snapshots].delete(snapshot_id)
+            response.status = true
+            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/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 = Fog::AWS::EC2.data[:volumes][volume_id]
+            Fog::AWS::EC2.data[:deleted_at][volume_id] = 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 = [])
+          response = Fog::Response.new
+          public_ip = [*public_ip]
+          if public_ip != []
+            addresses_set = Fog::AWS::EC2.data[:addresses].reject {|key, value| !public_ip.include?(key)}.values
+          else
+            addresses_set = Fog::AWS::EC2.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,64 @@
+unless Fog.mocking?
+
+  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
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def describe_availability_zones(zone_name = [])
+          response = Fog::Response.new
+          zone_name = [*zone_name]
+          zones = {
+            'us-east-1a' => {"zoneName"=>"us-east-1a", "regionName"=>"us-east-1", "zoneState"=>"available"}, 
+            'us-east-1b' => {"zoneName"=>"us-east-1b", "regionName"=>"us-east-1", "zoneState"=>"available"}, 
+            'us-east-1c' => {"zoneName"=>"us-east-1c", "regionName"=>"us-east-1", "zoneState"=>"available"}, 
+            'us-east-1d' => {"zoneName"=>"us-east-1d", "regionName"=>"us-east-1", "zoneState"=>"available"}
+          }
+          if zone_name != []
+            availability_zone_info = zones.reject {|key, value| !zone_name.include?(key)}.values
+          else
+            availability_zone_info = zones.values
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId'             => Fog::AWS::Mock.request_id,
+            'availabilityZoneInfo'  => availability_zone_info
+          }
+          response
+        end
+
+      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