fog-aws 3.0.0 → 3.10.0

data/lib/fog/aws/dns.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS < Fog::Service
+  module AWS
+    class DNS < Fog::Service
       extend Fog::AWS::CredentialFetcher::ServiceMethods
 
       requires :aws_access_key_id, :aws_secret_access_key
@@ -25,7 +25,10 @@ module Fog
       request :list_resource_record_sets
       request :get_change
 
+
       class Mock
+        include Fog::AWS::CredentialFetcher::ConnectionMethods
+
         def self.data
           @data ||= Hash.new do |hash, region|
             hash[region] = Hash.new do |region_hash, key|
@@ -70,6 +73,7 @@ module Fog
 
       class Real
         include Fog::AWS::CredentialFetcher::ConnectionMethods
+
         # Initialize connection to Route 53 DNS service
         #
         # ==== Notes
@@ -77,7 +81,7 @@ module Fog
         # :aws_secret_access_key in order to create a connection
         #
         # ==== Examples
-        #   dns = Fog::DNS::AWS.new(
+        #   dns = Fog::AWS::DNS.new(
         #     :aws_access_key_id => your_aws_access_key_id,
         #     :aws_secret_access_key => your_aws_secret_access_key
         #   )
@@ -147,9 +151,9 @@ module Fog
           else
             raise case match[:code]
             when 'NoSuchHostedZone', 'NoSuchChange' then
-              Fog::DNS::AWS::NotFound.slurp(error, match[:message])
+              Fog::AWS::DNS::NotFound.slurp(error, match[:message])
             else
-              Fog::DNS::AWS::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+              Fog::AWS::DNS::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
             end
           end
         end
@@ -160,6 +164,151 @@ module Fog
           Base64.encode64(signed_string).chomp!
         end
       end
+
+      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://docs.aws.amazon.com/general/latest/gr/rande.html#elb_region
+      # This needs to be kept in sync manually sadly for now as seemingly this data is not available via an API
+      def self.elb_dualstack_hosted_zone_mapping
+        @elb_dualstack_hosted_zone_mapping ||= {
+          "ap-northeast-1" => "Z14GRHDCWA56QT",
+          "ap-northeast-2" => "ZWKZPGTI48KDX",
+          "ap-northeast-3" => "Z5LXEXXYW11ES",
+          "ap-south-1" => "ZP97RAFLXTNZK",
+          "ap-southeast-1" => "Z1LMS91P8CMLE5",
+          "ap-southeast-2" => "Z1GM3OXH4ZPM65",
+          "ca-central-1" => "ZQSVJUPU6J1EY",
+          "eu-central-1" => "Z215JYRZR1TBD5",
+          "eu-west-1" => "Z32O12XQLNTSW2",
+          "eu-west-2" => "ZHURV8PSTC4K8",
+          "eu-west-3" => "Z3Q77PNBQS71R4",
+          "us-east-1" => "Z35SXDOTRQ7X7K",
+          "us-east-2" => "Z3AADJGX6KTTL2",
+          "us-west-1" => "Z368ELLRRE2KJ0",
+          "us-west-2" => "Z1H1FL5HABSF5",
+          "sa-east-1" => "Z2P70J7HTTTPLU",
+        }
+      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
+    end
+  end
+
+  # @deprecated
+  module DNS
+    # @deprecated
+    class AWS < Fog::AWS::DNS
+      # @deprecated
+      # @overrides Fog::Service.new (from the fog-core gem)
+      def self.new(*)
+        Fog::Logger.deprecation 'Fog::DNS::AWS is deprecated, please use Fog::AWS::DNS.'
+        super
+      end
     end
   end
 end

data/lib/fog/aws/efs.rb

@@ -64,7 +64,7 @@ module Fog
         end
 
         def mock_compute
-          @mock_compute ||= Fog::Compute::AWS.new(:aws_access_key_id => @aws_access_key_id, :aws_secret_access_key => @aws_secret_access_key, :region => @region)
+          @mock_compute ||= Fog::AWS::Compute.new(:aws_access_key_id => @aws_access_key_id, :aws_secret_access_key => @aws_secret_access_key, :region => @region)
         end
       end
 

data/lib/fog/aws/elasticache.rb

@@ -171,8 +171,10 @@ module Fog
           @aws_credentials_expire_at = Time::now + 20
           setup_credentials(options)
           @region = options[:region] || 'us-east-1'
-          unless ['ap-northeast-1', 'ap-southeast-1', 'eu-west-1', 'us-east-1',
-                  'us-west-1', 'us-west-2', 'sa-east-1'].include?(@region)
+          unless ['ap-south-1', 'ap-northeast-1', 'ap-northeast-2', 'ap-northeast-3', 'ap-southeast-1', 'ap-southeast-2', 
+                  'eu-west-1', 'eu-west-2', 'eu-west-3', 'eu-central-1',
+                  'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2', 'ca-central-1',
+                  'sa-east-1', 'cn-north-1', 'cn-northwest-1', 'ap-east-1', 'us-gov-west-1'].include?(@region)
             raise ArgumentError, "Unknown region: #{@region.inspect}"
           end
         end

data/lib/fog/aws/elb.rb

@@ -14,7 +14,7 @@ module Fog
       class ValidationError             < Fog::Errors::Error; end
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
+      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :version, :instrumentor, :instrumentor_name
 
       request_path 'fog/aws/requests/elb'
       request :configure_health_check
@@ -142,6 +142,7 @@ module Fog
           @port       = options[:port]        || 443
           @scheme     = options[:scheme]      || 'https'
           @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
+          @version ||= options[:version] || '2012-06-01'
 
           setup_credentials(options)
         end
@@ -178,7 +179,7 @@ module Fog
               :host               => @host,
               :path               => @path,
               :port               => @port,
-              :version            => '2012-06-01',
+              :version            => @version,
               :method             => 'POST'
           }
           )

data/lib/fog/aws/elbv2.rb

@@ -0,0 +1,72 @@
+module Fog
+  module AWS
+    class ELBV2 < ELB
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :version, :instrumentor, :instrumentor_name
+
+      request_path 'fog/aws/requests/elbv2'
+      request :add_tags
+      request :create_load_balancer
+      request :describe_tags
+      request :remove_tags
+      request :describe_load_balancers
+      request :describe_listeners
+
+      class Real < ELB::Real
+        def initialize(options={})
+          @version = '2015-12-01'
+
+          super(options)
+        end
+      end
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, region|
+            owner_id = Fog::AWS::Mock.owner_id
+            hash[region] = Hash.new do |region_hash, key|
+              region_hash[key] = {
+                :owner_id => owner_id,
+                :load_balancers_v2 => {}
+              }
+            end
+          end
+        end
+
+        def self.dns_name(name, region)
+          "#{name}-#{Fog::Mock.random_hex(8)}.#{region}.elb.amazonaws.com"
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        attr_reader :region
+
+        def initialize(options={})
+          @use_iam_profile = options[:use_iam_profile]
+
+          @region = options[:region] || 'us-east-1'
+          setup_credentials(options)
+
+          Fog::AWS.validate_region!(@region)
+        end
+
+        def setup_credentials(options)
+          @aws_access_key_id     = options[:aws_access_key_id]
+          @aws_secret_access_key = options[:aws_secret_access_key]
+
+          @signer = Fog::AWS::SignatureV4.new(@aws_access_key_id, @aws_secret_access_key,@region,'elasticloadbalancing')
+        end
+
+        def data
+          self.class.data[@region][@aws_access_key_id]
+        end
+
+        def reset_data
+          self.class.data[@region].delete(@aws_access_key_id)
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/glacier.rb

@@ -39,52 +39,114 @@ module Fog
           new.add_part(body)
         end
 
-        def reduce_digests(digests)
-          while digests.length > 1
-            digests = digests.each_slice(2).map do |pair|
-              if pair.length == 2
-                OpenSSL::Digest::SHA256.digest(pair[0]+pair[1])
-              else
-                pair.first
-              end
+        def initialize
+          @last_chunk_digest = nil	# Digest OBJECT for last chunk (Digest::SHA256)
+          @last_chunk_digest_temp = nil	# Digest VALUE for last chunk
+          @last_chunk_length = 0	# Length of last chunk, always smaller than 1MB.
+          @digest_stack = []
+          # First position on stack corresponds to 1MB, second 2MB, third 4MB, fourt 8MB and so on.
+          # In any time, the size of all already added parts is equal to sum of all existing (non-nil)
+          # positions multiplied by that number, plus last_chunk_length for the remainder smaller than
+          # one megabyte. So, if last_chunk_length is half megabyte, stack[0] is filled, stack[1] and 
+          # stack[2] empty and stack[3] filled, the size is 0.5MB + 1x1MB + 0x2MB + 0x4MB + 1x8MB = 9.5MB.
+        end
+
+        def update_digest_stack(digest, stack)
+          stack.each_with_index{|s,i|
+            if s
+              digest = Digest::SHA256.digest(s + digest)
+              stack[i] = nil
+            else
+              stack[i] = digest # Update this position with value obtained in previous run of cycle.
+              digest = nil
+              break
             end
-          end
-          digests.first
+          }
+          stack << digest if digest
         end
 
-        def initialize
-          @digests = []
+        def reduce_digest_stack(digest, stack)
+          stack.each_with_index{|s,i|
+            unless digest
+              digest = stack[i]
+              next
+            end
+            if stack[i]
+              digest = Digest::SHA256.digest(stack[i] + digest)
+            end
+          }
+          digest
         end
 
         def add_part(bytes)
           part = self.digest_for_part(bytes)
-          @digests << part
           part.unpack('H*').first
         end
 
-        def digest_for_part(body)
-          chunk_count = [body.bytesize / MEGABYTE + (body.bytesize % MEGABYTE > 0 ? 1 : 0), 1].max
+        def prepare_body_for_slice(body)
           if body.respond_to? :byteslice
-            digests_for_part = chunk_count.times.map {|chunk_index| OpenSSL::Digest::SHA256.digest(body.byteslice(chunk_index * MEGABYTE, MEGABYTE))}
+            r = yield(body, :byteslice)
           else
             if body.respond_to? :encoding
               old_encoding = body.encoding
               body.force_encoding('BINARY')
             end
-            digests_for_part = chunk_count.times.map {|chunk_index| OpenSSL::Digest::SHA256.digest(body.slice(chunk_index * MEGABYTE, MEGABYTE))}
+            r = yield(body, :slice)
             if body.respond_to? :encoding
               body.force_encoding(old_encoding)
             end
           end
-          reduce_digests(digests_for_part)
+          r
         end
 
-        def hexdigest
-          digest.unpack('H*').first
+        def digest_for_part(body)
+          part_stack = []
+          part_temp = nil
+          body_size = body.bytesize
+          prepare_body_for_slice(body) {|body, slice|
+            start_offset = 0
+            if @last_chunk_length != 0
+              start_offset = MEGABYTE - @last_chunk_length
+              @last_chunk_hash.update(body.send(slice, 0, start_offset))
+              hash = @last_chunk_hash.digest
+              @last_chunk_digest_temp = hash
+              if body_size > start_offset
+                @last_chunk_length = 0
+                @last_chunk_hash = nil
+                @last_chunk_digest_temp = nil
+                update_digest_stack(hash, @digest_stack)
+              else
+                part_temp = hash
+                @last_chunk_digest_temp = hash
+                @last_chunk_length += body_size
+                next
+              end
+            end
+            whole_chunk_count = (body_size - start_offset) / MEGABYTE
+            whole_chunk_count.times.each {|chunk_index|
+              hash = Digest::SHA256.digest(body.send(slice, start_offset + chunk_index * MEGABYTE, MEGABYTE))
+              update_digest_stack(hash, part_stack)
+              update_digest_stack(hash, @digest_stack)
+            }
+            rest_size = body_size - start_offset - whole_chunk_count * MEGABYTE
+            if rest_size > 0 || whole_chunk_count == 0
+              @last_chunk_hash = Digest::SHA256.new
+              @last_chunk_length = rest_size
+              @last_chunk_hash.update(body.send(slice, start_offset + whole_chunk_count * MEGABYTE, rest_size))
+              hash = @last_chunk_hash.digest
+              @last_chunk_digest_temp = hash
+              part_temp = hash
+            end
+          }
+          reduce_digest_stack(part_temp, part_stack)
         end
 
         def digest
-          reduce_digests(@digests)
+          reduce_digest_stack(@last_chunk_digest_temp, @digest_stack)
+        end
+
+        def hexdigest
+          digest.unpack('H*').first
         end
       end