fog 0.0.9 → 0.0.10

data/lib/fog/aws/models/ec2/snapshots.rb

@@ -2,45 +2,67 @@ module Fog
   module AWS
     class EC2
 
-      def snapshots
-        Fog::AWS::EC2::Snapshots.new(:connection => self)
+      def snapshots(attributes = {})
+        Fog::AWS::EC2::Snapshots.new({
+          :connection => self
+        }.merge!(attributes))
       end
 
       class Snapshots < Fog::Collection
 
+        attribute :snapshot_id
+        attribute :volume_id
+
+        def initialize(attributes)
+          @snapshot_id ||= []
+          super
+        end
+
         def all(snapshot_id = [])
-          data = connection.describe_snapshots(snapshot_id)
-          snapshots = Fog::AWS::EC2::Snapshots.new(:connection => connection)
-          data['snapshotSet'].each do |volume|
+          data = connection.describe_snapshots(snapshot_id).body
+          snapshots = Fog::AWS::EC2::Snapshots.new({
+            :connection   => connection,
+            :snapshot_id  => snapshot_id
+          }.merge!(attributes))
+          data['snapshotSet'].each do |snapshot|
             snapshots << Fog::AWS::EC2::Snapshot.new({
-              :connection => connection
+              :connection => connection,
+              :snapshots  => self
             }.merge!(snapshot))
           end
+          if volume_id
+            snapshots = snapshots.select {|snapshot| snapshot.volume_id == volume_id}
+          end
           snapshots
         end
 
         def create(attributes = {})
-          volume = new(attributes)
-          volume.save
-          volume
+          snapshot = new(attributes)
+          snapshot.save
+          snapshot
         end
 
-        def new(attributes = {})
-          Fog::AWS::S3::Snapshot.new({
-            :connection => connection,
-            :volume     => @volume,
-            :snapshots  => self
-          }.merge!(attributes))
+        def get(snapshot_id)
+          all(snapshot_id).first
+        rescue Fog::Errors::BadRequest
+          nil
         end
 
-        def volume
-          @volume
+        def new(attributes = {})
+          snapshot = Fog::AWS::EC2::Snapshot.new(
+            attributes.merge!(
+              :connection => connection,
+              :snapshots  => self
+            )
+          )
+          if volume_id
+            snapshot.volume_id = volume_id
+          end
+          snapshot
         end
 
-        private
-
-        def volume=(new_volume)
-          @volume = new_volume
+        def reload
+          all(snapshot_id)
         end
 
       end

data/lib/fog/aws/models/ec2/volume.rb

@@ -6,7 +6,8 @@ module Fog
 
         attribute :attachment_time,   'attachmentTime'
         attribute :availability_zone, 'availabilityZone'
-        attribute :device,            'createTime'
+        attribute :create_time,       'createTime'
+        attribute :device
         attribute :instance_id,       'instanceId'
         attribute :size
         attribute :snapshot_id,       'snapshotId'
@@ -15,30 +16,40 @@ module Fog
         
         def initialize(attributes = {})
           if attributes['attachmentSet']
-            attributes.merge!(attributes.delete('attachmentSet'))
+            attributes.merge!(attributes.delete('attachmentSet').first || {})
           end
           super
         end
 
-        def delete
+        def destroy
           connection.delete_volume(@volume_id)
           true
         end
 
+        def reload
+          new_attributes = volumes.get(@volume_id).attributes
+          merge_attributes(new_attributes)
+        end
+
         def save
           data = connection.create_volume(@availability_zone, @size, @snapshot_id).body
           new_attributes = data.reject {|key,value| key == 'requestId'}
-          update_attributes(new_attributes)
+          merge_attributes(new_attributes)
           true
         end
 
         def snapshots
-          @snapshots ||= begin
-            Fog::AWS::S3::Snapshots.new(
-              :connection => connection,
-              :volume     => self
-            )
-          end
+          connection.snapshots(:volume_id => volume_id)
+        end
+
+        def volumes
+          @volumes
+        end
+
+        private
+
+        def volumes=(new_volumes)
+          @volumes = new_volumes
         end
 
       end

data/lib/fog/aws/models/ec2/volumes.rb

@@ -8,12 +8,23 @@ module Fog
 
       class Volumes < Fog::Collection
 
+        attribute :volume_id
+
+        def initialize(attributes)
+          @volume_id ||= []
+          super
+        end
+
         def all(volume_id = [])
-          data = connection.describe_volumes(volume_id)
-          volumes = Fog::AWS::EC2::Volumes.new(:connection => connection)
+          data = connection.describe_volumes(volume_id).body
+          volumes = Fog::AWS::EC2::Volumes.new({
+            :connection => connection,
+            :volume_id  => volume_id
+          }.merge!(attributes))
           data['volumeSet'].each do |volume|
             volumes << Fog::AWS::EC2::Volume.new({
-              :connection => connection
+              :connection => connection,
+              :volumes    => self
             }.merge!(volume))
           end
           volumes
@@ -25,8 +36,23 @@ module Fog
           volume
         end
 
+        def get(volume_id)
+          all(volume_id).first
+        rescue Fog::Errors::BadRequest
+          nil
+        end
+
         def new(attributes = {})
-          Fog::AWS::EC2::Volume.new(attributes.merge!(:connection => connection))
+          Fog::AWS::EC2::Volume.new(
+            attributes.merge!(
+              :connection => connection,
+              :volumes    => self
+            )
+          )
+        end
+
+        def reload
+          all(volume_id)
         end
 
       end

data/lib/fog/aws/models/s3/buckets.rb

@@ -30,10 +30,7 @@ module Fog
 
         def get(name, options = {})
           remap_attributes(options, {
-            :is_truncated => 'IsTruncated',
-            :marker       => 'Marker',
-            :max_keys     => 'MaxKeys',
-            :prefix       => 'Prefix'
+            :max_keys     => 'max-keys',
           })
           data = connection.get_bucket(name, options).body
           bucket = Fog::AWS::S3::Bucket.new({
@@ -41,13 +38,13 @@ module Fog
             :connection => connection,
             :name       => data['Name']
           })
-          objects_data = {}
+          options = {}
           for key, value in data
-            if ['IsTruncated', 'Marker', 'MaxKeys', 'Prefix'].include?(key)
-              objects_data[key] = value
+            if ['Delimiter', 'IsTruncated', 'Marker', 'MaxKeys', 'Prefix'].include?(key)
+              options[key] = value
             end
           end
-          bucket.objects.merge_attributes(objects_data)
+          bucket.objects.merge_attributes(:options => options)
           data['Contents'].each do |object|
             owner = Fog::AWS::S3::Owner.new(object.delete('Owner').merge!(:connection => connection))
             bucket.objects << Fog::AWS::S3::Object.new({

data/lib/fog/aws/models/s3/objects.rb

@@ -4,14 +4,11 @@ module Fog
 
       class Objects < Fog::Collection
 
-        attribute :is_truncated,  'IsTruncated'
-        attribute :marker,        'Marker'
-        attribute :max_keys,      'MaxKeys'
-        attribute :prefix,        'Prefix'
+        attribute :options
 
         def all(options = {})
-          merge_attributes(options)
-          bucket.buckets.get(bucket.name, attributes).objects
+          merge_attributes(:options => options)
+          bucket.buckets.get(bucket.name, @options).objects
         end
 
         def bucket
@@ -74,7 +71,7 @@ module Fog
         end
 
         def reload
-          all
+          all(@options)
         end
 
         private

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

@@ -1,32 +1,68 @@
-module Fog
-  module AWS
-    class EC2
-
-      # Add permissions to a security group
-      #
-      # ==== Parameters
-      # * options<~Hash>:
-      #   * 'GroupName'<~String> - Name of group
-      #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
-      #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
-      #   or
-      #   * 'CidrIp' - CIDR range
-      #   * 'FromPort' - Start of port range (or -1 for ICMP wildcard)
-      #   * 'GroupName' - Name of group to modify
-      #   * 'IpProtocol' - Ip protocol, must be in ['tcp', 'udp', 'icmp']
-      #   * 'ToPort' - End of port range (or -1 for ICMP wildcard)
-      #
-      # === Returns
-      # * response<~Fog::AWS::Response>:
-      #   * body<~Hash>:
-      #     * 'requestId'<~String> - Id of request
-      #     * 'return'<~Boolean> - success?
-      def authorize_security_group_ingress(options = {})
-        request({
-          'Action' => 'AuthorizeSecurityGroupIngress'
-        }.merge!(options), Fog::Parsers::AWS::EC2::Basic.new)
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Add permissions to a security group
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'GroupName'<~String> - Name of group
+        #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
+        #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
+        #   or
+        #   * 'CidrIp' - CIDR range
+        #   * 'FromPort' - Start of port range (or -1 for ICMP wildcard)
+        #   * 'GroupName' - Name of group to modify
+        #   * 'IpProtocol' - Ip protocol, must be in ['tcp', 'udp', 'icmp']
+        #   * 'ToPort' - End of port range (or -1 for ICMP wildcard)
+        #
+        # === Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def authorize_security_group_ingress(options = {})
+          request({
+            'Action' => 'AuthorizeSecurityGroupIngress'
+          }.merge!(options), Fog::Parsers::AWS::EC2::Basic.new)
+        end
+
       end
+    end
+  end
+
+else
 
+  module Fog
+    module AWS
+      class EC2
+
+        # TODO: handle the GroupName/Source/Source case
+        def authorize_security_group_ingress(options = {})
+          response = Fog::Response.new
+          group = Fog::AWS::EC2.data[:security_groups][options['GroupName']]
+
+          group['ipPermissions'] ||= []
+          group['ipPermissions'] << {
+            'groups'      => [],
+            'fromPort'    => options['FromPort'],
+            'ipRanges'    => [{ 'cidrIp' => options['CidrIp'] }],
+            'ipProtocol'  => options['IpProtocol'],
+            'toPort'      => options['ToPort']
+          }
+
+          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/create_security_group.rb

@@ -37,10 +37,10 @@ else
           response = Fog::Response.new
           unless Fog::AWS::EC2.data[:security_groups][name]
             data = {
-              'GroupDescription'  => description,
-              'GroupName'         => name,
+              'groupDescription'  => description,
+              'groupName'         => name,
               'ipPermissions'     => [],
-              'OwnerId'           => Fog::AWS::Mock.owner_id
+              'ownerId'           => Fog::AWS::Mock.owner_id
             }
             Fog::AWS::EC2.data[:security_groups][name] = data
             response.body = {

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

@@ -1,41 +1,71 @@
-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))
+unless Fog.mocking?
+
+  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
-        request({
-          'Action' => 'DescribeImages'
-        }.merge!(options), Fog::Parsers::AWS::EC2::DescribeImages.new)
+
       end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
 
+        def describe_images(options = {})
+          response = Fog::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