fog-aws 0.0.5

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

@@ -0,0 +1,32 @@
+module Fog
+  module AWS
+    class DataPipeline
+      class Real
+        # List all pipelines
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_ListPipelines.html
+        # ==== Parameters
+        # * Marker <~String> - The starting point for the results to be returned.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def list_pipelines(options={})
+          params = {}
+          params['Marker'] = options[:marker] if options[:marker]
+
+          response = request({
+            :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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+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
+
+        class JSONObject
+          def initialize(object)
+            @json_fields = object.clone
+            @id = @json_fields.delete('id')
+            @name = @json_fields.delete('name') || @id
+          end
+
+          def to_api
+            {
+              'id' => @id,
+              'name' => @name,
+              'fields' => fields
+            }
+          end
+
+          private
+
+          def fields
+            @json_fields.map{|k,v| field_for_kv(k,v)}.flatten
+          end
+
+          def field_for_kv(key, value)
+            if value.is_a?(Hash)
+              { 'key' => key, 'refValue' => value['ref'] }
+
+            elsif value.is_a?(Array)
+              value.map { |subvalue| field_for_kv(key, subvalue) }
+
+            else
+              { 'key' => key, 'stringValue' => value }
+
+            end
+          end
+        end
+      end
+
+      class Mock
+        def put_pipeline_definition(id, objects)
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class DataPipeline
+      class Real
+        # Queries a pipeline for the names of objects that match a specified set of conditions.
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_QueryObjects.html
+        # ==== Parameters
+        # * PipelineId <~String> - The ID of the pipeline
+        # * Sphere <~String> - Specifies whether the query applies to components or instances.
+        #                      Allowable values: COMPONENT, INSTANCE, ATTEMPT.
+        # * Marker <~String> - The starting point for the results to be returned.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def query_objects(id, sphere, options={})
+          params = {
+            'pipelineId' => id,
+            'sphere' => sphere,
+          }
+          params['marker'] = options[:marker] if options[:marker]
+
+          response = request({
+            :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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+module Fog
+  module DNS
+    class AWS
+      class Real
+        require 'fog/aws/parsers/dns/change_resource_record_sets'
+
+        # Use this action to create or change your authoritative DNS information for a zone
+        # http://docs.amazonwebservices.com/Route53/latest/DeveloperGuide/RRSchanges.html#RRSchanges_API
+        #
+        # ==== Parameters
+        # * zone_id<~String> - ID of the zone these changes apply to
+        # * options<~Hash>
+        #   * comment<~String> - Any comments you want to include about the change.
+        # * change_batch<~Array> - The information for a change request
+        #   * changes<~Hash> -
+        #     * action<~String> - 'CREATE' or 'DELETE'
+        #     * name<~String>   - This must be a fully-specified name, ending with a final period
+        #     * type<~String>   - A | AAAA | CNAME | MX | NS | PTR | SOA | SPF | SRV | TXT
+        #     * ttl<~Integer>   - Time-to-live value - omit if using an alias record
+        #     * weight<~Integer>   - Time-to-live value - omit if using an alias record
+        #     * set_identifier<~String> - An identifier that differentiates among multiple resource record sets that have the same combination of DNS name and type.
+        #     * region<~String> - The Amazon EC2 region where the resource that is specified in this resource record set resides.  (Latency only)
+        #     * failover<~String> - To configure failover, you add the Failover element to two resource record sets. For one resource record set, you specify PRIMARY as the value for Failover; for the other resource record set, you specify SECONDARY.
+        #     * geo_location<~String XML> - A complex type currently requiring XML that lets you control how Amazon Route 53 responds to DNS queries based on the geographic origin of the query.
+        #     * health_check_id<~String> - If you want Amazon Route 53 to return this resource record set in response to a DNS query only when a health check is passing, include the HealthCheckId element and specify the ID of the applicable health check.
+        #     * resource_records<~Array> - Omit if using an alias record
+        #     * alias_target<~Hash> - Information about the domain to which you are redirecting traffic (Alias record sets only)
+        #       * dns_name<~String> - The Elastic Load Balancing domain to which you want to reroute traffic
+        #       * hosted_zone_id<~String> - The ID of the hosted zone that contains the Elastic Load Balancing domain to which you want to reroute traffic
+        #       * evaluate_target_health<~Boolean> - Applies only to alias, weighted alias, latency alias, and failover alias resource record sets: If you set the value of EvaluateTargetHealth to true, the alias resource record sets inherit the health of the referenced resource record sets.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ChangeInfo'<~Hash>
+        #       * 'Id'<~String> - The ID of the request
+        #       * 'Status'<~String> - status of the request - PENDING | INSYNC
+        #       * 'SubmittedAt'<~String> - The date and time the change was made
+        #   * status<~Integer> - 200 when successful
+        #
+        # ==== Examples
+        #
+        # Example changing a CNAME record:
+        #
+        #     change_batch_options = [
+        #       {
+        #         :action => "DELETE",
+        #         :name => "foo.example.com.",
+        #         :type => "CNAME",
+        #         :ttl => 3600,
+        #         :resource_records => [ "baz.example.com." ]
+        #       },
+        #       {
+        #         :action => "CREATE",
+        #         :name => "foo.example.com.",
+        #         :type => "CNAME",
+        #         :ttl => 3600,
+        #         :resource_records => [ "bar.example.com." ]
+        #       }
+        #     ]
+        #
+        #     change_resource_record_sets("ABCDEFGHIJKLMN", change_batch_options)
+        #
+        def change_resource_record_sets(zone_id, change_batch, 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]
+                %Q{<GeoLocation>#{change_item[:geo_location]}</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
+
+          body = %Q{<?xml version="1.0" encoding="UTF-8"?><ChangeResourceRecordSetsRequest xmlns="https://route53.amazonaws.com/doc/#{@version}/">#{changes}</ChangeResourceRecordSetsRequest>}
+          request({
+            :body       => body,
+            :parser     => Fog::Parsers::DNS::AWS::ChangeResourceRecordSets.new,
+            :expects    => 200,
+            :method     => 'POST',
+            :path       => "hostedzone/#{zone_id}/rrset"
+          })
+        end
+      end
+
+      class Mock
+        def change_resource_record_sets(zone_id, change_batch, options = {})
+          response = Excon::Response.new
+          errors   = []
+
+          if (zone = self.data[:zones][zone_id])
+            response.status = 200
+
+            change_id = Fog::AWS::Mock.change_id
+            change_batch.each do |change|
+              case change[:action]
+              when "CREATE"
+                if zone[:records][change[:type]].nil?
+                  zone[:records][change[:type]] = {}
+                end
+
+                if zone[:records][change[:type]][change[:name]].nil?
+                  # raise change.to_s if change[:resource_records].nil?
+                  zone[:records][change[:type]][change[:name]] =
+                  if change[:alias_target]
+                    record = {
+                      :alias_target => change[:alias_target]
+                    }
+                  else
+                    record = {
+                      :ttl => change[:ttl].to_s,
+                    }
+                  end
+                  zone[:records][change[:type]][change[:name]] = {
+                    :change_id => change_id,
+                    :resource_records => change[:resource_records] || [],
+                    :name => change[:name],
+                    :type => change[:type]
+                  }.merge(record)
+                else
+                  errors << "Tried to create resource record set #{change[:name]}. type #{change[:type]}, but it already exists"
+                end
+              when "DELETE"
+                if zone[:records][change[:type]].nil? || zone[:records][change[:type]].delete(change[:name]).nil?
+                  errors << "Tried to delete resource record set #{change[:name]}. type #{change[:type]}, but it was not found"
+                end
+              end
+            end
+
+            if errors.empty?
+              change = {
+                :id => change_id,
+                :status => 'PENDING',
+                :submitted_at => Time.now.utc.iso8601
+              }
+              self.data[:changes][change[:id]] = change
+              response.body = {
+                'Id' => change[:id],
+                'Status' => change[:status],
+                'SubmittedAt' => change[:submitted_at]
+              }
+              response
+            else
+              response.status = 400
+              response.body = "<?xml version=\"1.0\"?><InvalidChangeBatch xmlns=\"https://route53.amazonaws.com/doc/2012-02-29/\"><Messages>#{errors.map {|e| "<Message>#{e}</Message>"}.join()}</Messages></InvalidChangeBatch>"
+              raise(Excon::Errors.status_error({:expects => 200}, response))
+            end
+          else
+            response.status = 404
+            response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>NoSuchHostedZone</Code><Message>A hosted zone with the specified hosted zone ID does not exist.</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestID></Response>"
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+        end
+      end
+
+      def self.hosted_zone_for_alias_target(dns_name)
+        k = elb_hosted_zone_mapping.keys.find do |k|
+          dns_name =~ /\A.+\.#{k}\.elb\.amazonaws\.com\.?\z/
+        end
+        elb_hosted_zone_mapping[k]
+      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",
+          "sa-east-1"      => "Z2ES78Y61JGQKS",
+          "us-east-1"      => "Z3DZXE0Q79N41H",
+          "us-west-1"      => "Z1M58G0W56PQJA",
+          "us-west-2"      => "Z33MTJ483KN6FU",
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Fog
+  module DNS
+    class AWS
+      class Real
+        require 'fog/aws/parsers/dns/health_check'
+
+        # This action creates a new health check.
+        # http://docs.aws.amazon.com/Route53/latest/APIReference/API_CreateHealthCheck.html
+        #
+        # ==== Parameters (options as symbols Hash)
+        # * ip_address<~String> - (optional if fqdn) The IPv4 IP address of the endpoint on which you want Amazon Route 53 to perform health checks
+        # * port<~Integer> - The port on the endpoint on which you want Amazon Route 53 to perform health checks
+        # * type<~String> - HTTP | HTTPS | HTTP_STR_MATCH | HTTPS_STR_MATCH | TCP
+        # * resource_path<~Stringy> - (required for all types except TCP) The path that you want Amazon Route 53 to request when performing health checks. The path can be any value for which your endpoint will return an HTTP status code of 2xx or 3xx when the endpoint is healthy
+        # * fqdn<~String> - (optional if ip_address) The value that you want Amazon Route 53 to pass in the Host header in all health checks except TCP health checks
+        # * search_string<~String> - If the value of Type is HTTP_STR_MATCH or HTTP_STR_MATCH, the string that you want Amazon Route 53 to search for in the response body from the specified resource
+        # * request_interval<~String> - 10 | 30 (optional) The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health-check request
+        # * failure_threshold<~Integer> - 1-10 (optional) The number of consecutive health checks that an endpoint must pass or fail for Amazon Route 53 to change the current status of the endpoint from unhealthy to healthy or vice versa
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'HealthCheck'<~Hash>
+        #       * 'Id'<~String> - The ID of the request
+        #       * 'CallerReference'<~String> - A unique string that identifies the request and that allows failed CreateHealthCheck requests to be retried without the risk of executing the operation twice.
+        #       * 'HealthCheckConfig'<~Hash>
+        #         * 'IPAddress'
+        #         * 'Port'
+        #         * 'Type'
+        #         * 'ResourcePath'
+        #         * 'FullyQualifiedDomainName'
+        #         * 'RequestInterval'
+        #         * 'FailureThreshold'
+        #   * status<~Integer> - 201 when successful
+
+        def create_health_check(ip_address, port, type, options = {})
+          version = @version
+          builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+            xml.CreateHealthCheckRequest(:xmlns => "https://route53.amazonaws.com/doc/#{version}/") do
+              xml.CallerReference options[:caller_reference] || "#{Time.now.to_i.to_s}-#{SecureRandom.hex(6)}"
+              xml.HealthCheckConfig do
+                xml.IPAddress ip_address unless ip_address.nil?
+                xml.Port port
+                xml.Type type
+                xml.ResourcePath options[:resource_path] if options.has_key?(:resource_path)
+                xml.FullyQualifiedDomainName options[:fqdn] if options.has_key?(:fqdn)
+                xml.SearchString options[:search_string] if options.has_key?(:search_string)
+                xml.RequestInterval options[:request_interval] if options.has_key?(:request_interval)
+                xml.FailureThreshold options[:failure_threshold] if options.has_key?(:failure_threshold)
+              end
+            end
+          end
+
+          request({
+            :body    => builder.to_xml.to_s,
+            :expects => 201,
+            :method  => 'POST',
+            :path    => 'healthcheck',
+            :parser  => Fog::Parsers::DNS::AWS::HealthCheck.new
+          })
+        end
+      end
+    end
+  end
+end