fog 0.3.7 → 0.3.8

data/lib/fog/aws/parsers/compute/describe_tags.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Parsers
+    module AWS
+      module Compute
+
+        class DescribeTags < Fog::Parsers::Base
+
+          def reset
+            @tag = {}
+            @response = { 'tagSet' => [] }
+          end
+
+          def end_element(name)
+            case name
+            when 'resourceId', 'resourceType', 'key', 'value'
+              @tag[name] = @value
+            when 'item'
+              @response['tagSet'] << @tag
+              @tag = {}
+            when 'requestId'
+              @response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/compute/describe_volumes.rb

@@ -9,13 +9,17 @@ module Fog
             @attachment = {}
             @in_attachment_set = false
             @response = { 'volumeSet' => [] }
-            @volume = { 'attachmentSet' => [] }
+            @tag = {}
+            @volume = { 'attachmentSet' => [], 'tagSet' => {} }
           end
 
           def start_element(name, attrs = [])
             super
-            if name == 'attachmentSet'
+            case name
+            when 'attachmentSet'
               @in_attachment_set = true
+            when 'tagSet'
+              @in_tag_set = true
             end
           end
 
@@ -32,6 +36,16 @@ module Fog
                 @volume['attachmentSet'] << @attachment
                 @attachment = {}
               end
+            elsif @in_tag_set
+              case name
+              when 'key', 'value'
+                @tag[name] = @value
+              when 'item'
+                @volume['tagSet'][@tag['key']] = @tag['value']
+                @tag = {}
+              when 'tagSet'
+                @in_tag_set = false
+              end
             else
               case name
               when 'availabilityZone', 'snapshotId', 'status', 'volumeId'
@@ -40,7 +54,7 @@ module Fog
                 @volume[name] = Time.parse(@value)
               when 'item'
                 @response['volumeSet'] << @volume
-                @volume = { 'attachmentSet' => [] }
+                @volume = { 'attachmentSet' => [], 'tagSet' => {} }
               when 'requestId'
                 @response[name] = @value
               when 'size'

data/lib/fog/aws/parsers/compute/run_instances.rb

@@ -27,10 +27,10 @@ module Fog
             case name
             when 'amiLaunchIndex'
               @instance[name] = @value.to_i
-            when 'architecture', 'dnsName', 'imageId', 'instanceId',
-                  'instanceType', 'ipAddress', 'kernelId', 'keyName',
-                  'privateDnsName', 'privateIpAddress', 'ramdiskId', 'reason',
-                  'rootDeviceType'
+            when 'architecture', 'clientToken', 'dnsName', 'imageId',
+                  'instanceId', 'instanceType', 'ipAddress', 'kernelId',
+                  'keyName', 'privateDnsName', 'privateIpAddress', 'ramdiskId',
+                  'reason', 'rootDeviceType'
               @instance[name] = @value
             when 'availabilityZone'
               @instance['placement'][name] = @value

data/lib/fog/aws/parsers/storage/get_bucket.rb

@@ -33,7 +33,7 @@ module Fog
               @response['MaxKeys'] = @value.to_i
             when 'Size'
               @object['Size'] = @value.to_i
-            when 'Delimeter', 'Key', 'Name', 'StorageClass'
+            when 'Delimeter', 'Key', 'StorageClass'
               @object[name] = @value
             end
           end

data/lib/fog/aws/parsers/storage/get_bucket_logging.rb

@@ -3,7 +3,7 @@ module Fog
     module AWS
       module Storage
 
-        class AccessControlList < Fog::Parsers::Base
+        class GetBucketLogging < Fog::Parsers::Base
 
           def reset
             @grant = { 'Grantee' => {} }

data/lib/fog/aws/parsers/storage/get_bucket_object_versions.rb

@@ -65,17 +65,17 @@ module Fog
               elsif @in_version
                 @version
               end['LastModified'] = Time.parse(@value)
-            when 'KeyMarker', 'Name', 'Prefix', 'VersionIdMarker'
-              @response[name] = @value
             when 'MaxKeys'
               @response['MaxKeys'] = @value.to_i
             when 'Size'
               @version['Size'] = @value.to_i
-            when 'Key', 'Name', 'StorageClass', 'VersionId'
+            when 'Key', 'KeyMarker', 'Name', 'Prefix', 'StorageClass', 'VersionId', 'VersionIdMarker'
               if @in_delete_marker
                 @delete_marker
               elsif @in_version
                 @version
+              else
+                @response
               end[name] = @value
             end
           end

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

@@ -51,6 +51,7 @@ module Fog
             response.body = {
               'requestId' => Fog::AWS::Mock.request_id
             }.merge!(data)
+            @data[:snapshots][snapshot_id]['tagSet'] = {}
           else
             response.status = 400
             raise(Excon::Errors.status_error({:expects => 200}, response))

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

@@ -0,0 +1,78 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Adds tags to resources
+        #
+        # ==== Parameters
+        # * resources<~String> - One or more resources to tag
+        # * tags<~String> - hash of key value tag pairs to assign
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def create_tags(resources, tags)
+          resources = [*resources]
+          for key, value in tags
+            if value.nil?
+              tags[key] = ''
+            end
+          end
+          params = {}
+          params.merge!(AWS.indexed_param('ResourceId', resources))
+          params.merge!(AWS.indexed_param('Tag.%d.Key', tags.keys))
+          params.merge!(AWS.indexed_param('Tag.%d.Value', tags.values))
+          request({
+            'Action'            => 'CreateTags',
+            :parser             => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def create_tags(resources, tags)
+          resources = [*resources]
+
+          tagged = resources.map do |resource_id|
+            type = case resource_id
+            when /^ami\-[a-z0-9]{8}$/i
+              'image'
+            when /^i\-[a-z0-9]{8}$/i
+              'instance'
+            when /^snap\-[a-z0-9]{8}$/i
+              'snapshot'
+            when /^vol\-[a-z0-9]{8}$/i
+              'volume'
+            end
+            if type && @data[:"#{type}s"][resource_id]
+              { 'resourceId' => resource_id, 'resourceType' => type }
+            else
+              raise(Fog::Service::NotFound.new("The #{type} ID '#{resource_id}' does not exist"))
+            end
+          end
+
+          tags.each do |key, value|
+            @data[:tags][key] ||= {}
+            @data[:tags][key][value] ||= []
+            @data[:tags][key][value] = @data[:tags][key][value] & tagged
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Remove tags from resources
+        #
+        # ==== Parameters
+        # * resources<~String> - One or more resources to tag
+        # * tags<~String> - hash of key value tag pairs to assign
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_tags(resources, tags)
+          resources = [*resources]
+          for key, value in tags
+            if value.nil?
+              tags[key] = ''
+            end
+          end
+          params = {}
+          params.merge!(AWS.indexed_param('ResourceId', resources))
+          params.merge!(AWS.indexed_param('Tag.%d.Key', tags.keys))
+          params.merge!(AWS.indexed_param('Tag.%d.Value', tags.values))
+          request({
+            'Action'            => 'CreateTags',
+            :parser             => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def delete_tags(resources, tags)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module Fog
         # Describe all or specified IP addresses.
         #
         # ==== Parameters
-        # * public_ip<~Array> - List of ips to describe, defaults to all
+        # * filters<~Hash> - List of filters to limit results with
         #
         # ==== Returns
         # * response<~Excon::Response>:
@@ -17,8 +17,12 @@ module Fog
         #     * 'addressesSet'<~Array>:
         #       * 'instanceId'<~String> - instance for ip address
         #       * 'publicIp'<~String> - ip address for instance
-        def describe_addresses(public_ip = [])
-          params = AWS.indexed_param('PublicIp', public_ip)
+        def describe_addresses(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_addresses with #{filters.class} param is deprecated, use describe_addresses('public-ip' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'public-ip' => [*filters]}
+          end
+          params = AWS.indexed_filters(filters)
           request({
             'Action'    => 'DescribeAddresses',
             :idempotent => true,
@@ -30,24 +34,28 @@ module Fog
 
       class Mock
 
-        def describe_addresses(public_ip = [])
-          response = Excon::Response.new
-          public_ip = [*public_ip]
-          if public_ip != []
-            addresses_set = @data[:addresses].reject {|key, value| !public_ip.include?(key)}.values
-          else
-            addresses_set = @data[:addresses].values
+        def describe_addresses(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_addresses with #{filters.class} param is deprecated, use describe_addresses('public-ip' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'public-ip' => [*filters]}
           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
-            }
-            response
-          else
-            raise Fog::AWS::Compute::NotFound.new("Address #{public_ip.inspect} not found.")
+
+          response = Excon::Response.new
+
+          addresses_set = @data[:addresses].values
+
+          aliases = {'public-ip' => 'publicIp', 'instance-id' => 'instanceId'}
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            addresses_set = addresses_set.reject{|address| ![*filter_value].include?(address[aliased_key])}
           end
+
+          response.status = 200
+          response.body = {
+            'requestId'     => Fog::AWS::Mock.request_id,
+            'addressesSet'  => addresses_set
+          }
+          response
         end
 
       end

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

@@ -8,7 +8,7 @@ module Fog
         # Describe all or specified availability zones
         #
         # ==== Params
-        # * zone_name<~String> - List of availability zones to describe, defaults to all
+        # * filters<~Hash> - List of filters to limit results with
         #
         # ==== Returns
         # * response<~Excon::Response>:
@@ -18,8 +18,12 @@ module Fog
         #       * 'regionName'<~String> - Name of region
         #       * 'zoneName'<~String> - Name of zone
         #       * 'zoneState'<~String> - State of zone
-        def describe_availability_zones(zone_name = [])
-          params = AWS.indexed_param('ZoneName', zone_name)
+        def describe_availability_zones(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_availability_zones with #{filters.class} param is deprecated, use describe_availability_zones('zone-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'public-ip' => [*filters]}
+          end
+          params = AWS.indexed_filters(filters)
           request({
             'Action'    => 'DescribeAvailabilityZones',
             :idempotent => true,
@@ -31,31 +35,33 @@ module Fog
 
       class Mock
 
-        def describe_availability_zones(zone_name = [])
-          response = Excon::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
+        def describe_availability_zones(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_availability_zones with #{filters.class} param is deprecated, use describe_availability_zones('zone-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'public-ip' => [*filters]}
           end
 
-          if zone_name.length == 0 || zone_name.length == availability_zone_info.length
-            response.status = 200
-            response.body = {
-              'requestId'             => Fog::AWS::Mock.request_id,
-              'availabilityZoneInfo'  => availability_zone_info
-            }
-            response
-          else
-            raise Fog::AWS::Compute::Error.new("InvalidParameterValue => Invalid availability zone: #{zone_name.inspect}")
+          response = Excon::Response.new
+
+          availability_zone_info = [
+            {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1a", "zoneState" => "available"},
+            {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1b", "zoneState" => "available"},
+            {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1c", "zoneState" => "available"},
+            {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1d", "zoneState" => "available"},
+          ]
+
+          aliases = {'region-name' => 'regionName', 'zone-name' => 'zoneName', 'state' => 'zoneState'}
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            availability_zone_info = availability_zone_info.reject{|availability_zone| ![*filter_value].include?(availability_zone[aliased_key])}
           end
+
+          response.status = 200
+          response.body = {
+            'availabilityZoneInfo'  => availability_zone_info,
+            'requestId'             => Fog::AWS::Mock.request_id
+          }
+          response
         end
 
       end

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

@@ -8,7 +8,8 @@ module Fog
         # Describe all or specified images.
         #
         # ==== Params
-        # * options<~Hash> - Optional params
+        # * filters<~Hash> - List of filters to limit results with
+        #   * filters and/or the following
         #   * 'ExecutableBy'<~String> - Only return images that the executable_by
         #     user has explicit permission to launch
         #   * 'ImageId'<~Array> - Ids of images to describe
@@ -33,10 +34,14 @@ module Fog
         #       * 'ramdiskId'<~String> - Ramdisk id associated with image, if any
         #       * 'rootDeviceName'<~String> - Root device name, e.g. /dev/sda1
         #       * 'rootDeviceType'<~String> - Root device type, ebs or instance-store
-        def describe_images(options = {})
-          if image_id = options.delete('ImageId')
-            options.merge!(AWS.indexed_param('ImageId', image_id))
+        def describe_images(filters = {})
+          options = {}
+          for key in ['ExecutableBy', 'ImageId', 'Owner']
+            if filters.is_a?(Hash) && filters.key?(key)
+              options[key] = filters[key]
+            end
           end
+          params = AWS.indexed_filters(filters).merge!(options)
           request({
             'Action'    => 'DescribeImages',
             :idempotent => true,
@@ -48,20 +53,8 @@ module Fog
 
       class Mock
 
-        def describe_images(options = {})
-          response = Excon::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
+        def describe_images(filters = {})
+          Fog::Mock.not_implemented
         end
 
       end