fog 1.6.0 → 1.7.0

data/lib/fog/aws/requests/cdn/get_invalidation.rb

@@ -0,0 +1,60 @@
+module Fog
+  module CDN
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/cdn/get_invalidation'
+
+        # ==== Parameters
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Id'<~String> - Invalidation id
+        #     * 'Status'<~String>
+        #     * 'CreateTime'<~String>
+        #     * 'InvalidationBatch'<~Array>:
+        #       * 'Path'<~String>
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudFront/2010-11-01/APIReference/GetInvalidation.html
+
+        def get_invalidation(distribution_id, invalidation_id)
+          request({
+            :expects    => 200,
+            :idempotent => true,
+            :method   => 'GET',
+            :parser   => Fog::Parsers::CDN::AWS::GetInvalidation.new,
+            :path       => "/distribution/#{distribution_id}/invalidation/#{invalidation_id}"
+          })
+        end
+
+      end
+
+      class Mock
+
+        def get_invalidation(distribution_id, invalidation_id)
+          distribution = self.data[:distributions][distribution_id]
+          unless distribution
+            Fog::CDN::AWS::Mock.error(:no_such_distribution)
+          end
+
+          invalidation = self.data[:invalidations][distribution_id][invalidation_id]
+          unless invalidation
+            Fog::CDN::AWS::Mock.error(:no_such_invalidation)
+          end
+
+          if invalidation['Status'] == 'InProgress' && (Time.now - Time.parse(invalidation['CreateTime']) >= Fog::Mock.delay * 2)
+            invalidation['Status'] = 'Completed'
+            distribution['InProgressInvalidationBatches'] -= 1
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = invalidation
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/cdn/get_invalidation_list.rb

@@ -37,6 +37,47 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def get_invalidation_list(distribution_id, options = {})
+          distribution = self.data[:distributions][distribution_id]
+          unless distribution
+            Fog::CDN::AWS::Mock.error(:no_such_distribution)
+          end
+
+          invalidations = (self.data[:invalidations][distribution_id] || {}).values
+
+          invalidations.each do |invalidation|
+            if invalidation['Status'] == 'InProgress' && (Time.now - Time.parse(invalidation['CreateTime']) >= Fog::Mock.delay * 2)
+              invalidation['Status'] = 'Completed'
+              distribution['InProgressInvalidationBatches'] -= 1
+            end
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'Marker' => Fog::Mock.random_hex(16),
+            'IsTruncated' => false,
+            'MaxItems' => 100,
+            'InvalidationSummary' => invalidations.map { |i| to_invalidation_summary(i) }
+          }
+          response
+        end
+
+        private
+
+        def to_invalidation_summary(d)
+          {
+            'Id' => d['Id'],
+            'Status' => d['Status']
+          }
+        end
+
+      end
+
     end
   end
 end

data/lib/fog/aws/requests/cdn/get_streaming_distribution.rb

@@ -45,6 +45,32 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def get_streaming_distribution(distribution_id)
+          response = Excon::Response.new
+
+          distribution = self.data[:streaming_distributions][distribution_id]
+          unless distribution
+            Fog::CDN::AWS::Mock.error(:no_such_streaming_distribution)
+          end
+
+          if distribution['Status'] == 'InProgress' && (Time.now - Time.parse(distribution['LastModifiedTime']) >= Fog::Mock.delay * 2)
+            distribution['Status'] = 'Deployed'
+          end
+
+          etag = Fog::CDN::AWS::Mock.generic_id
+          response.status = 200
+          response.body = distribution.reject { |k,v| k == 'ETag' }
+
+          response.headers['ETag'] = etag
+          distribution['ETag'] = etag
+
+          response
+        end
+      end
+
     end
   end
 end

data/lib/fog/aws/requests/cdn/get_streaming_distribution_list.rb

@@ -54,6 +54,36 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def get_streaming_distribution_list(options = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          distributions = self.data[:streaming_distributions].values
+
+          response.body = {
+            'Marker' => Fog::Mock.random_hex(16),
+            'IsTruncated' => false,
+            'MaxItems' => 100,
+            'StreamingDistributionSummary' => distributions.map { |d| to_streaming_distribution_summary(d) }
+          }
+
+          response
+        end
+
+        private
+
+        def to_streaming_distribution_summary(d)
+          {
+            'DomainName' => d['DomainName'],
+            'Id' => d['Id'],
+            'LastModifiedTime' => d['LastModifiedTime']
+          }.merge(d['StreamingDistributionConfig'])
+        end
+      end
+
     end
   end
 end

data/lib/fog/aws/requests/cdn/post_distribution.rb

@@ -86,6 +86,50 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        require 'time'
+
+        def post_distribution(options = {})
+          if self.data[:distributions].values.any? { |d| (d['CNAME'] & (options['CNAME']||[])).empty? }
+            Fog::CDN::AWS::Mock.error(:invalid_argument, 'CNAME is already in use')
+          end
+
+          response = Excon::Response.new
+
+          response.status = 201
+          options['CallerReference'] = Time.now.to_i.to_s
+
+          dist_id = Fog::CDN::AWS::Mock.distribution_id
+
+          distribution = {
+            'DomainName' => Fog::CDN::AWS::Mock.domain_name,
+            'Id' => dist_id,
+            'Status' => 'InProgress',
+            'LastModifiedTime' => Time.now.utc.iso8601,
+            'InProgressInvalidationBatches' => 0,
+            'DistributionConfig' => {
+              'CallerReference' => options['CallerReference'],
+              'CNAME' => options['CNAME'] || [],
+              'Comment' => options['Comment'],
+              'Enabled' => options['Enabled'],
+              'Logging' => {
+                'Bucket' => options['Bucket'],
+                'Prefix' => options['Prefix']
+              },
+              'S3Origin' => options['S3Origin'],
+              'CustomOrigin' => options['CustomOrigin'],
+              'TrustedSigners' => options['TrustedSigners'] || []
+            }
+          }
+
+          self.data[:distributions][dist_id] = distribution
+
+          response.body = distribution
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/cdn/post_invalidation.rb

@@ -46,6 +46,39 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def post_invalidation(distribution_id, paths, caller_reference = Time.now.to_i.to_s)
+          distribution = self.data[:distributions][distribution_id]
+          if distribution
+            invalidation_id = Fog::CDN::AWS::Mock.distribution_id
+            invalidation = {
+              'Id' => invalidation_id,
+              'Status' => 'InProgress',
+              'CreateTime' => Time.now.utc.iso8601,
+              'InvalidationBatch' => {
+                'CallerReference' => caller_reference,
+                'Path' => paths
+              }
+            }
+
+            distribution['InProgressInvalidationBatches'] += 1
+
+            self.data[:invalidations][distribution_id] ||= {}
+            self.data[:invalidations][distribution_id][invalidation_id] = invalidation
+
+            response = Excon::Response.new
+            response.status = 201
+            response.body = invalidation
+            response
+          else
+            Fog::CDN::AWS::Mock.error(:no_such_distribution)
+          end
+        end
+
+      end
+
     end
   end
 end

data/lib/fog/aws/requests/cdn/post_streaming_distribution.rb

@@ -73,6 +73,50 @@ module Fog
         end
 
       end
+
+
+      class Mock
+
+        require 'time'
+
+        def post_streaming_distribution(options = {})
+          if self.data[:streaming_distributions].values.any? { |d| (d['CNAME'] & (options['CNAME']||[])).empty? }
+            Fog::CDN::AWS::Mock.error(:invalid_argument, 'CNAME is already in use')
+          end
+
+          response = Excon::Response.new
+
+          response.status = 201
+          options['CallerReference'] = Time.now.to_i.to_s
+
+          dist_id = Fog::CDN::AWS::Mock.distribution_id
+
+          distribution = {
+            'DomainName' => Fog::CDN::AWS::Mock.domain_name,
+            'Id' => dist_id,
+            'Status' => 'InProgress',
+            'LastModifiedTime' => Time.now.utc.iso8601,
+            'StreamingDistributionConfig' => {
+              'CallerReference' => options['CallerReference'],
+              'CNAME' => options['CNAME'] || [],
+              'Comment' => options['Comment'],
+              'Enabled' => options['Enabled'],
+              'Logging' => {
+                'Bucket' => options['Bucket'],
+                'Prefix' => options['Prefix']
+              },
+              'S3Origin' => options['S3Origin'],
+              'TrustedSigners' => options['TrustedSigners'] || []
+            }
+          }
+
+          self.data[:streaming_distributions][dist_id] = distribution
+
+          response.body = distribution
+          response
+        end
+      end
+
     end
   end
 end

data/lib/fog/aws/requests/cdn/put_distribution_config.rb

@@ -89,6 +89,34 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def put_distribution_config(distribution_id, etag, options = {})
+          distribution = self.data[:distributions][distribution_id]
+
+          if distribution
+            if distribution['ETag'] != etag
+              Fog::CDN::AWS::Mock.error(:invalid_if_match_version)
+            end
+            unless distribution['DistributionConfig']['CallerReference']
+              Fog::CDN::AWS::Mock.error(:illegal_update)
+            end
+
+            distribution['DistributionConfig'].merge!(options)
+            distribution['Status'] = 'InProgress'
+
+            response = Excon::Response.new
+            response.status = 200
+            response.headers['ETag'] = Fog::CDN::AWS::Mock.generic_id
+            response.body = distribution.merge({ 'LastModifiedTime' => Time.now.utc.iso8601 }).reject{ |k,v| k == 'ETag' }
+            response
+          else
+            Fog::CDN::AWS::Mock.error(:no_such_distribution)
+          end
+        end
+      end
+
     end
   end
 end

data/lib/fog/aws/requests/cdn/put_streaming_distribution_config.rb

@@ -78,6 +78,34 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def put_streaming_distribution_config(distribution_id, etag, options = {})
+          distribution = self.data[:streaming_distributions][distribution_id]
+
+          if distribution
+            if distribution['ETag'] != etag
+              Fog::CDN::AWS::Mock.error(:invalid_if_match_version)
+            end
+            unless distribution['StreamingDistributionConfig']['CallerReference']
+              Fog::CDN::AWS::Mock.error(:illegal_update)
+            end
+
+            distribution['StreamingDistributionConfig'].merge!(options)
+            distribution['Status'] = 'InProgress'
+
+            response = Excon::Response.new
+            response.status = 200
+            response.headers['ETag'] = Fog::CDN::AWS::Mock.generic_id
+            response.body = distribution.merge({ 'LastModifiedTime' => Time.now.utc.iso8601 }).reject{ |k,v| k == 'ETag' }
+            response
+          else
+            Fog::CDN::AWS::Mock.error(:no_such_streaming_distribution)
+          end
+        end
+      end
+
     end
   end
 end

data/lib/fog/aws/requests/compute/create_image.rb

@@ -20,15 +20,27 @@ module Fog
         #     * 'requestId'<~String> - Id of request.
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateImage.html]
-        def create_image(instance_id, name, description, no_reboot = false)
-          request(
+        def create_image(instance_id, name, description, no_reboot = false, options={})
+          params = {}
+          block_device_mappings = options[:block_device_mappings] ||  []
+
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.DeviceName', block_device_mappings.map{|mapping| mapping['DeviceName']}) 
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.NoDevice', block_device_mappings.map{|mapping| mapping['NoDevice']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.VirtualName', block_device_mappings.map{|mapping| mapping['VirtualName']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.SnapshotId', block_device_mappings.map{|mapping| mapping['Ebs.SnapshotId']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.DeleteOnTermination', block_device_mappings.map{|mapping| mapping['Ebs.DeleteOnTermination']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.VolumeType', block_device_mappings.map{|mapping| mapping['Ebs.VolumeType']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.Iops', block_device_mappings.map{|mapping| mapping['Ebs.Iops']})
+          params.reject!{|k,v| v.nil?}
+
+          request({
             'Action'            => 'CreateImage',
             'InstanceId'        => instance_id,
             'Name'              => name,
             'Description'       => description,
             'NoReboot'          => no_reboot.to_s,
             :parser             => Fog::Parsers::Compute::AWS::CreateImage.new
-          )
+          }.merge!(params))
         end
       end
 
@@ -39,13 +51,28 @@ module Fog
         # AWS[:compute].create_image("i-ac65ee8c", "test", "something")
         #
         
-        def create_image(instance_id, name, description, no_reboot = false)
+        def create_image(instance_id, name, description, no_reboot = false, options = {})
+          params = {}
+          block_device_mappings = options[:block_device_mappings] || []
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.DeviceName', block_device_mappings.map{|mapping| mapping['DeviceName']}) 
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.NoDevice', block_device_mappings.map{|mapping| mapping['NoDevice']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.VirtualName', block_device_mappings.map{|mapping| mapping['VirtualName']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.SnapshotId', block_device_mappings.map{|mapping| mapping['Ebs.SnapshotId']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.DeleteOnTermination', block_device_mappings.map{|mapping| mapping['Ebs.DeleteOnTermination']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.VolumeType', block_device_mappings.map{|mapping| mapping['Ebs.VolumeType']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.Iops', block_device_mappings.map{|mapping| mapping['Ebs.Iops']})
+          params.reject!{|k,v| v.nil?}
+
+          reserved_ebs_root_device  = '/dev/sda1'
+          block_devices = options.delete(:block_device_mappings) || []
+          register_image_response = register_image(name, description, reserved_ebs_root_device, block_devices, options)
+
           response = Excon::Response.new
           if instance_id && !name.empty?
             response.status = 200
             response.body = {
               'requestId' => Fog::AWS::Mock.request_id,
-              'imageId' => Fog::AWS::Mock.image_id
+              'imageId' => register_image_response.body['imageId']
             }
           else
             response.status = 400