fog-aws 0.11.0 → 3.18.0

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/start_stop_instances'
 
@@ -16,19 +16,27 @@ module Fog
         #     * TODO: fill in the blanks
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-StopInstances.html]
-        def stop_instances(instance_id, force = false)
+        def stop_instances(instance_id, options = {})
           params = Fog::AWS.indexed_param('InstanceId', instance_id)
-          params.merge!('Force' => 'true') if force
+          unless options.is_a?(Hash)
+            Fog::Logger.warning("stop_instances with #{options.class} param is deprecated, use stop_instances('force' => boolean) instead [light_black](#{caller.first})[/]")
+            options = {'force' => options}
+          end
+          params.merge!('Force' => 'true') if options['force']
+          if options['hibernate']
+            params.merge!('Hibernate' => 'true')
+            params.merge!('Force' => 'false')
+          end
           request({
             'Action'    => 'StopInstances',
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::StartStopInstances.new
+            :parser     => Fog::Parsers::AWS::Compute::StartStopInstances.new
           }.merge!(params))
         end
       end
 
       class Mock
-        def stop_instances(instance_id, force = false)
+        def stop_instances(instance_id, options = {})
           instance_ids = Array(instance_id)
 
           instance_set = self.data[:instances].values
@@ -36,7 +44,7 @@ module Fog
           instance_set = instance_set.select {|x| instance_ids.include?(x["instanceId"]) }
 
           if instance_set.empty?
-            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_ids.first}' does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_ids.first}' does not exist")
           else
             response = Excon::Response.new
             response.status = 200

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/terminate_instances'
 
@@ -28,7 +28,7 @@ module Fog
           request({
             'Action'    => 'TerminateInstances',
             :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::TerminateInstances.new
+            :parser     => Fog::Parsers::AWS::Compute::TerminateInstances.new
           }.merge!(params))
         end
       end
@@ -73,7 +73,7 @@ module Fog
 
             describe_addresses.body['addressesSet'].each do |address|
               if instance_id.include?(address['instanceId'])
-                disassociate_address(address['publicIp'])
+                disassociate_address(address['publicIp'], address['associationId'])
               end
             end
 
@@ -85,7 +85,7 @@ module Fog
 
             response
           else
-            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist")
           end
         end
       end

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Real
         require 'fog/aws/parsers/compute/monitor_unmonitor_instances'
 
@@ -22,7 +22,7 @@ module Fog
           request({
                           'Action' => 'UnmonitorInstances',
                           :idempotent => true,
-                          :parser => Fog::Parsers::Compute::AWS::MonitorUnmonitorInstances.new
+                          :parser => Fog::Parsers::AWS::Compute::MonitorUnmonitorInstances.new
                   }.merge!(params))
         end
       end
@@ -35,7 +35,7 @@ module Fog
             if instance = self.data[:instances][instance_id]
               instance['monitoring']['state'] = 'enabled'
             else
-              raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_ids}' does not exist")
+              raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_ids}' does not exist")
             end
           end
           instances_set = [*instance_ids].reduce([]) { |memo, id| memo << {'instanceId' => id, 'monitoring' => 'disabled'} }

data/lib/fog/aws/requests/data_pipeline/activate_pipeline.rb

@@ -14,16 +14,20 @@ module Fog
 
           response = request({
             :body => Fog::JSON.encode(params),
-            :headers => { 'X-Amz-Target' => 'DataPipeline.ActivatePipeline' },
+            :headers => { 'X-Amz-Target' => 'DataPipeline.ActivatePipeline' }
           })
-
-          Fog::JSON.decode(response.body)
         end
       end
 
       class Mock
         def activate_pipeline(id)
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+
+          pipeline = find_pipeline(id)
+          pipeline[:active] = true
+
+          response.body = {}
+          response
         end
       end
     end

data/lib/fog/aws/requests/data_pipeline/create_pipeline.rb

@@ -24,14 +24,35 @@ module Fog
             :body => Fog::JSON.encode(params),
             :headers => { 'X-Amz-Target' => 'DataPipeline.CreatePipeline' },
           })
-
-          Fog::JSON.decode(response.body)
         end
       end
 
       class Mock
         def create_pipeline(unique_id, name, description=nil, tags=nil)
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+
+          if existing_pipeline = self.data[:pipelines][unique_id]
+            {"pipelineId" => existing_pipeline["pipelineId"]}
+          else
+            pipeline_id = Fog::AWS::Mock.data_pipeline_id
+            mapped_tags = if tags
+                            tags.map { |k,v| {"key" => k.to_s, "value" => v.to_s}}
+                          else
+                            []
+                          end
+
+            pipeline = {
+              "name"        => name,
+              "description" => description,
+              "fields"      => mapped_tags,
+              "pipelineId"  => pipeline_id,
+            }
+
+            self.data[:pipelines][unique_id] = pipeline
+
+            response.body = {"pipelineId" => pipeline_id}
+          end
+          response
         end
       end
     end

data/lib/fog/aws/requests/data_pipeline/deactivate_pipeline.rb

@@ -0,0 +1,36 @@
+module Fog
+  module AWS
+    class DataPipeline
+      class Real
+        # Activate a pipeline
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_DectivatePipeline.html
+        # ==== Parameters
+        # * PipelineId <~String> - The ID of the pipeline to activate
+        # ' cancelActive <~Boolean> - Indicates whether to cancel any running objects. The default is true, which sets the state of any running objects to CANCELED. If this value is false, the pipeline is deactivated after all running objects finish.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def deactivate_pipeline(id, cancel_active=true)
+          params = { 'pipelineId' => id, 'cancelActive' => cancel_active }
+
+          response = request({
+            :body => Fog::JSON.encode(params),
+            :headers => { 'X-Amz-Target' => 'DataPipeline.DectivatePipeline' }
+          })
+        end
+      end
+
+      class Mock
+        def deactivate_pipeline(id, cancel_active=true)
+          response = Excon::Response.new
+
+          pipeline = find_pipeline(id)
+          pipeline[:active] = false
+
+          response.body = {}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/data_pipeline/delete_pipeline.rb

@@ -22,7 +22,12 @@ module Fog
 
       class Mock
         def delete_pipeline(id)
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+
+          pipeline = find_pipeline(id)
+          pipeline[:deleted] = true
+
+          true
         end
       end
     end

data/lib/fog/aws/requests/data_pipeline/describe_objects.rb

@@ -23,14 +23,28 @@ module Fog
             :body => Fog::JSON.encode(params),
             :headers => { 'X-Amz-Target' => 'DataPipeline.DescribeObjects' },
           })
-
-          Fog::JSON.decode(response.body)
         end
       end
 
       class Mock
         def describe_objects(id, objects, options={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+
+          find_pipeline(id)
+
+          pipeline_objects = self.data[:pipeline_definitions][id]["pipelineObjects"].select { |o| objects.include?(o["id"]) }
+
+          response.body = {
+            "hasMoreResults"  => false,
+            "marker"          => options[:marker],
+            "pipelineObjects" => [
+              {
+                "fields" => pipeline_objects
+              }
+            ]
+          }
+
+          response
         end
       end
     end

data/lib/fog/aws/requests/data_pipeline/describe_pipelines.rb

@@ -17,14 +17,14 @@ module Fog
             :body => Fog::JSON.encode(params),
             :headers => { 'X-Amz-Target' => 'DataPipeline.DescribePipelines' },
           })
-
-          Fog::JSON.decode(response.body)
         end
       end
 
       class Mock
         def describe_pipelines(ids)
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          response.body = {"pipelineDescriptionList" => self.data[:pipelines].values.select { |p| !p[:deleted] && ids.include?(p["pipelineId"]) } }
+          response
         end
       end
     end

data/lib/fog/aws/requests/data_pipeline/get_pipeline_definition.rb

@@ -18,14 +18,17 @@ module Fog
             :body => Fog::JSON.encode(params),
             :headers => { 'X-Amz-Target' => 'DataPipeline.GetPipelineDefinition' },
           })
-
-          Fog::JSON.decode(response.body)
         end
       end
 
       class Mock
-        def get_pipeline_definition(id, objects)
-          Fog::Mock.not_implemented
+        def get_pipeline_definition(id)
+          response = Excon::Response.new
+
+          pipeline = find_pipeline(id)
+
+          response.body = self.data[:pipeline_definitions][id] || {"pipelineObjects" => []}
+          response
         end
       end
     end

data/lib/fog/aws/requests/data_pipeline/list_pipelines.rb

@@ -17,14 +17,14 @@ module Fog
             :body => Fog::JSON.encode(params),
             :headers => { 'X-Amz-Target' => 'DataPipeline.ListPipelines' },
           })
-
-          Fog::JSON.decode(response.body)
         end
       end
 
       class Mock
         def list_pipelines(options={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          response.body = {"pipelineIdList" => self.data[:pipelines].values.map { |p| {"id" => p["pipelineId"], "name" => p["name"]} } }
+          response
         end
       end
     end

data/lib/fog/aws/requests/data_pipeline/put_pipeline_definition.rb

@@ -1,35 +1,7 @@
 module Fog
   module AWS
     class DataPipeline
-      class Real
-        # Put raw pipeline definition JSON
-        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_PutPipelineDefinition.html
-        # ==== Parameters
-        # * PipelineId <~String> - The ID of the pipeline
-        # * PipelineObjects <~String> - Objects in the pipeline
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        def put_pipeline_definition(id, objects)
-          params = {
-            'pipelineId' => id,
-            'pipelineObjects' => transform_objects(objects),
-          }
-
-          response = request({
-            :body => Fog::JSON.encode(params),
-            :headers => { 'X-Amz-Target' => 'DataPipeline.PutPipelineDefinition' },
-          })
-
-          Fog::JSON.decode(response.body)
-        end
-
-        # Take a list of pipeline object hashes as specified in the Data Pipeline JSON format
-        # and transform it into the format expected by the API
-        def transform_objects(objects)
-          objects.map { |object| JSONObject.new(object).to_api }
-        end
-
+      module Shared
         class JSONObject
           def initialize(object)
             @json_fields = object.clone
@@ -53,7 +25,7 @@ module Fog
 
           def field_for_kv(key, value)
             if value.is_a?(Hash)
-              { 'key' => key, 'refValue' => value['ref'] }
+              { 'key' => key, 'refValue' => value['ref'], 'stringValue' => value['stringValue'] }
 
             elsif value.is_a?(Array)
               value.map { |subvalue| field_for_kv(key, subvalue) }
@@ -64,11 +36,60 @@ module Fog
             end
           end
         end
+
+        # Take a list of pipeline object hashes as specified in the Data Pipeline JSON format
+        # and transform it into the format expected by the API
+        def transform_objects(objects)
+          objects.map { |object| JSONObject.new(object).to_api }
+        end
+      end
+
+      class Real
+        include Shared
+        # Put raw pipeline definition JSON
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_PutPipelineDefinition.html
+        # ==== Parameters
+        # * PipelineId <~String> - The ID of the pipeline
+        # * PipelineObjects <~String> - Objects in the pipeline
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def put_pipeline_definition(id, pipeline_objects, options={})
+          params = {
+            'pipelineId' => id,
+            'pipelineObjects' => transform_objects(pipeline_objects),
+          }.merge(options)
+
+          response = request({
+            :body => Fog::JSON.encode(params),
+            :headers => { 'X-Amz-Target' => 'DataPipeline.PutPipelineDefinition' },
+          })
+        end
       end
 
       class Mock
-        def put_pipeline_definition(id, objects)
-          Fog::Mock.not_implemented
+        include Shared
+
+        def put_pipeline_definition(id, pipeline_objects, _options={})
+          response = Excon::Response.new
+          options  = _options.dup
+
+          pipeline = find_pipeline(id)
+
+          stringified_objects = if pipeline_objects.any?
+                                  transform_objects(stringify_keys(pipeline_objects))
+                                else
+                                  options.each { |k,v| options[k] = transform_objects(stringify_keys(v)) }
+                                end
+
+          if stringified_objects.is_a?(Array)
+            stringified_objects = {"pipelineObjects" => stringified_objects}
+          end
+
+          self.data[:pipeline_definitions][id] = stringified_objects
+
+          response.body = {"errored" => false, "validationErrors" => [], "validationWarnings" => []}
+          response
         end
       end
     end

data/lib/fog/aws/requests/data_pipeline/query_objects.rb

@@ -23,14 +23,17 @@ module Fog
             :body => Fog::JSON.encode(params),
             :headers => { 'X-Amz-Target' => 'DataPipeline.QueryObjects' },
           })
-
-          Fog::JSON.decode(response.body)
         end
       end
 
       class Mock
         def query_objects(id, sphere, options={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+
+          find_pipeline(id)
+
+          response.body = {"hasMoreResults" => false, "ids" => ["Default"]}
+          response
         end
       end
     end

data/lib/fog/aws/requests/dns/change_resource_record_sets.rb

@@ -1,131 +1,6 @@
 module Fog
-  module DNS
-    class AWS
-
-      def self.hosted_zone_for_alias_target(dns_name)
-        hosted_zones = if dns_name.match(/^dualstack\./)
-          elb_dualstack_hosted_zone_mapping
-        else
-          elb_hosted_zone_mapping
-        end
-
-        Hash[hosted_zones.select { |k, _|
-          dns_name =~ /\A.+\.#{k}\.elb\.amazonaws\.com\.?\z/
-        }].values.last
-      end
-
-      def self.elb_hosted_zone_mapping
-        @elb_hosted_zone_mapping ||= {
-          "ap-northeast-1" => "Z2YN17T5R711GT",
-          "ap-southeast-1" => "Z1WI8VXHPB1R38",
-          "ap-southeast-2" => "Z2999QAZ9SRTIC",
-          "eu-west-1"      => "Z3NF1Z3NOM5OY2",
-          "eu-central-1"   => "Z215JYRZR1TBD5",
-          "sa-east-1"      => "Z2ES78Y61JGQKS",
-          "us-east-1"      => "Z3DZXE0Q79N41H",
-          "us-west-1"      => "Z1M58G0W56PQJA",
-          "us-west-2"      => "Z33MTJ483KN6FU",
-        }
-      end
-
-      # See https://forums.aws.amazon.com/message.jspa?messageID=612414
-      def self.elb_dualstack_hosted_zone_mapping
-        @elb_dualstack_hosted_zone_mapping ||= {
-          "ap-northeast-1" => "Z14GRHDCWA56QT",
-          "ap-southeast-1" => "Z1LMS91P8CMLE5",
-          "ap-southeast-2" => "Z1GM3OXH4ZPM65",
-          "eu-central-1"   => "Z215JYRZR1TBD5",
-          "eu-west-1"      => "Z32O12XQLNTSW2",
-          "sa-east-1"      => "Z2P70J7HTTTPLU",
-          "us-east-1"      => "Z35SXDOTRQ7X7K",
-          "us-west-1"      => "Z368ELLRRE2KJ0",
-          "us-west-2"      => "Z1H1FL5HABSF5",
-        }
-      end
-
-      # Returns the xml request for a given changeset
-      def self.change_resource_record_sets_data(zone_id, change_batch, version, options = {})
-        # AWS methods return zone_ids that looks like '/hostedzone/id'.  Let the caller either use
-        # that form or just the actual id (which is what this request needs)
-        zone_id = zone_id.sub('/hostedzone/', '')
-
-        optional_tags = ''
-        options.each do |option, value|
-          case option
-          when :comment
-            optional_tags += "<Comment>#{value}</Comment>"
-          end
-        end
-
-        #build XML
-        if change_batch.count > 0
-
-          changes = "<ChangeBatch>#{optional_tags}<Changes>"
-
-          change_batch.each do |change_item|
-            action_tag = %Q{<Action>#{change_item[:action]}</Action>}
-            name_tag   = %Q{<Name>#{change_item[:name]}</Name>}
-            type_tag   = %Q{<Type>#{change_item[:type]}</Type>}
-
-            # TTL must be omitted if using an alias record
-            ttl_tag = ''
-            ttl_tag += %Q{<TTL>#{change_item[:ttl]}</TTL>} unless change_item[:alias_target]
-
-            weight_tag = ''
-            set_identifier_tag = ''
-            region_tag = ''
-            if change_item[:set_identifier]
-              set_identifier_tag += %Q{<SetIdentifier>#{change_item[:set_identifier]}</SetIdentifier>}
-              if change_item[:weight] # Weighted Record
-                weight_tag += %Q{<Weight>#{change_item[:weight]}</Weight>}
-              elsif change_item[:region] # Latency record
-                region_tag += %Q{<Region>#{change_item[:region]}</Region>}
-              end
-            end
-
-            failover_tag = if change_item[:failover]
-                             %Q{<Failover>#{change_item[:failover]}</Failover>}
-                           end
-
-            geolocation_tag = if change_item[:geo_location]
-                                xml_geo = change_item[:geo_location].map { |k,v| "<#{k}>#{v}</#{k}>" }.join
-                                %Q{<GeoLocation>#{xml_geo}</GeoLocation>}
-                              end
-
-            resource_records = change_item[:resource_records] || []
-            resource_record_tags = ''
-            resource_records.each do |record|
-              resource_record_tags += %Q{<ResourceRecord><Value>#{record}</Value></ResourceRecord>}
-            end
-
-            # ResourceRecords must be omitted if using an alias record
-            resource_tag = ''
-            resource_tag += %Q{<ResourceRecords>#{resource_record_tags}</ResourceRecords>} if resource_records.any?
-
-            alias_target_tag = ''
-            if change_item[:alias_target]
-              # Accept either underscore or camel case for hash keys.
-              dns_name = change_item[:alias_target][:dns_name] || change_item[:alias_target][:DNSName]
-              hosted_zone_id = change_item[:alias_target][:hosted_zone_id] || change_item[:alias_target][:HostedZoneId] || AWS.hosted_zone_for_alias_target(dns_name)
-              evaluate_target_health = change_item[:alias_target][:evaluate_target_health] || change_item[:alias_target][:EvaluateTargetHealth] || false
-              evaluate_target_health_xml = !evaluate_target_health.nil? ? %Q{<EvaluateTargetHealth>#{evaluate_target_health}</EvaluateTargetHealth>} : ''
-              alias_target_tag += %Q{<AliasTarget><HostedZoneId>#{hosted_zone_id}</HostedZoneId><DNSName>#{dns_name}</DNSName>#{evaluate_target_health_xml}</AliasTarget>}
-            end
-
-            health_check_id_tag = if change_item[:health_check_id]
-                                    %Q{<HealthCheckId>#{change_item[:health_check_id]}</HealthCheckId>}
-                                  end
-
-            change_tags = %Q{<Change>#{action_tag}<ResourceRecordSet>#{name_tag}#{type_tag}#{set_identifier_tag}#{weight_tag}#{region_tag}#{failover_tag}#{geolocation_tag}#{ttl_tag}#{resource_tag}#{alias_target_tag}#{health_check_id_tag}</ResourceRecordSet></Change>}
-            changes += change_tags
-          end
-
-          changes += '</Changes></ChangeBatch>'
-        end
-
-        %Q{<?xml version="1.0" encoding="UTF-8"?><ChangeResourceRecordSetsRequest xmlns="https://route53.amazonaws.com/doc/#{version}/">#{changes}</ChangeResourceRecordSetsRequest>}
-      end
-
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/change_resource_record_sets'
 
@@ -186,11 +61,11 @@ module Fog
         #     change_resource_record_sets("ABCDEFGHIJKLMN", change_batch_options)
         #
         def change_resource_record_sets(zone_id, change_batch, options = {})
-          body = AWS.change_resource_record_sets_data(zone_id, change_batch, @version, options)
+          body = Fog::AWS::DNS.change_resource_record_sets_data(zone_id, change_batch, @version, options)
           request({
             :body       => body,
             :idempotent => true,
-            :parser     => Fog::Parsers::DNS::AWS::ChangeResourceRecordSets.new,
+            :parser     => Fog::Parsers::AWS::DNS::ChangeResourceRecordSets.new,
             :expects    => 200,
             :method     => 'POST',
             :path       => "hostedzone/#{zone_id}/rrset"
@@ -294,10 +169,10 @@ module Fog
               }
               response
             else
-              raise Fog::DNS::AWS::Error.new("InvalidChangeBatch => #{errors.join(", ")}")
+              raise Fog::AWS::DNS::Error.new("InvalidChangeBatch => #{errors.join(", ")}")
             end
           else
-            raise Fog::DNS::AWS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone ID does not exist.")
+            raise Fog::AWS::DNS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone ID does not exist.")
           end
         end
       end

data/lib/fog/aws/requests/dns/create_health_check.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/health_check'
 
@@ -55,7 +55,7 @@ module Fog
             :expects => 201,
             :method  => 'POST',
             :path    => 'healthcheck',
-            :parser  => Fog::Parsers::DNS::AWS::HealthCheck.new
+            :parser  => Fog::Parsers::AWS::DNS::HealthCheck.new
           })
         end
       end

data/lib/fog/aws/requests/dns/create_hosted_zone.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/create_hosted_zone'
 
@@ -48,7 +48,7 @@ module Fog
 
           request({
             :body    => %Q{<?xml version="1.0" encoding="UTF-8"?><CreateHostedZoneRequest xmlns="https://route53.amazonaws.com/doc/#{@version}/"><Name>#{name}</Name>#{optional_tags}</CreateHostedZoneRequest>},
-            :parser  => Fog::Parsers::DNS::AWS::CreateHostedZone.new,
+            :parser  => Fog::Parsers::AWS::DNS::CreateHostedZone.new,
             :expects => 201,
             :method  => 'POST',
             :path    => "hostedzone"
@@ -102,7 +102,7 @@ module Fog
             }
             response
           else
-            raise Fog::DNS::AWS::Error.new("DelegationSetNotAvailable => Amazon Route 53 allows some duplication, but Amazon Route 53 has a maximum threshold of duplicated domains. This error is generated when you reach that threshold. In this case, the error indicates that too many hosted zones with the given domain name exist. If you want to create a hosted zone and Amazon Route 53 generates this error, contact Customer Support.")
+            raise Fog::AWS::DNS::Error.new("DelegationSetNotAvailable => Amazon Route 53 allows some duplication, but Amazon Route 53 has a maximum threshold of duplicated domains. This error is generated when you reach that threshold. In this case, the error indicates that too many hosted zones with the given domain name exist. If you want to create a hosted zone and Amazon Route 53 generates this error, contact Customer Support.")
           end
         end
       end

data/lib/fog/aws/requests/dns/delete_health_check.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         # This action deletes a health check.
         # http://docs.aws.amazon.com/Route53/latest/APIReference/API_DeleteHealthCheck.html