right_support 2.6.8 → 2.6.9

data/lib/right_support/net/dns.rb

@@ -9,11 +9,21 @@
 # License Agreement between RightScale.com, Inc. and the licensee.
 
 require 'socket'
+require 'uri'
 
 module RightSupport::Net
-
   module DNS
+    DEFAULT_RESOLVE_OPTIONS = {
+      :address_family => Socket::AF_INET,
+      :socket_type    => Socket::SOCK_STREAM,
+      :protocol       => Socket::IPPROTO_TCP,
+      :retry          => 3
+    }
 
+    # Resolve a set of DNS hostnames to the individual IP addresses to which they map. Only handles
+    # IPv4 addresses.
+    #
+    # @deprecated due to broken error handling - do not use; please use #resolve instead!
     def self.resolve_all_ip_addresses(hostnames)
       ips       = []
       hostnames = [hostnames] unless hostnames.respond_to?(:each)
@@ -35,6 +45,74 @@ module RightSupport::Net
       ips
     end
 
+    # Perform DNS resolution on a set of endpoints, where the endpoints may be hostnames or URIs.
+    # Expand out the list to include one entry per distinct address that is assigned to a given
+    # hostname, but preserve other aspects of the endpoints --. URIs will remain URIs with the
+    # same protocol, path-info, and so forth, but the hostname component will be resolved to IP
+    # addresses and the URI will be duplicated in the output, once for each distinct IP address.
+    #
+    # Although this method does accept IPv4 dotted-quad addresses as input, it does not accept
+    # IPv6 addresses. However, given hostnames or URIs as input, one _can_ resolve the hostnames
+    # to IPv6 addresses by specifying the appropriate address_family in the options.
+    #
+    # It should never be necessary to specify a different :socket_type or :protocol, but these
+    # options are exposed just in case.
+    #
+    # @param [Array<String>] endpoints a mixed list of hostnames, IPv4 addresses or URIs that contain them
+    # @option opts [Integer] :retry number of times to retry SocketError; default is 3
+    # @option opts [Integer] :address_family what kind of IP addresses to resolve; default is Socket::AF_INET (IPv4)
+    # @option opts [Integer] :socket_type socket-type context to pass to getaddrinfo, default is Socket::SOCK_STREAM
+    # @option opts [Integer] :protocol protocol context to pass to getaddrinfo, default is Socket::IPPROTO_TCP
+    #
+    # @return [Array<String>] larger list of endpoints with all hostnames resolved to IP addresses
+    #
+    # @raise URI::InvalidURIError if endpoints contains an invalid or URI
+    # @raise SocketError if endpoints contains an invalid or unresolvable hostname
+    def self.resolve(endpoints, opts={})
+      opts = DEFAULT_RESOLVE_OPTIONS.merge(opts)
+      endpoints = [endpoints] unless endpoints.respond_to?(:each)
+
+      resolved_endpoints = []
+      retries = 0
+
+      endpoints.each do |endpoint|
+        begin
+          if endpoint.include?(':')
+            # It contains a colon, therefore it must be a URI -- we don't support IPv6
+            uri = URI.parse(endpoint)
+            hostname = uri.host
+            raise URI::InvalidURIError, "Could not parse host component of URI" unless hostname
+
+            infos = Socket.getaddrinfo(hostname, nil,
+                                       opts[:address_family], opts[:socket_type], opts[:protocol])
+
+            infos.each do |info|
+              transformed_uri = uri.dup
+              transformed_uri.host = info[3]
+              resolved_endpoints << transformed_uri.to_s
+            end
+          else
+            # No colon; it's a hostname or IP address
+            infos = Socket.getaddrinfo(endpoint, nil,
+                                       opts[:address_family], opts[:socket_type], opts[:protocol])
+
+            infos.each do |info|
+              resolved_endpoints << info[3]
+            end
+          end
+        rescue SocketError => e
+          retries += 1
+          if retries < opts[:retry]
+            retry
+          else
+            raise e
+          end
+        end
+      end
+
+      resolved_endpoints
+    end
+
   end
 end
 

data/lib/right_support/net/request_balancer.rb

@@ -112,12 +112,13 @@ module RightSupport::Net
     end
 
     def resolve(endpoints)
-      endpoints = RightSupport::Net::DNS.resolve_all_ip_addresses(endpoints)
+      resolved_endpoints = RightSupport::Net::DNS.resolve(endpoints)
       @resolved_at = Time.now.to_i
-      endpoints
+      logger.info("RequestBalancer: resolved #{endpoints.inspect} to #{resolved_endpoints.inspect}")
+      resolved_endpoints
     end
 
-    def expired?
+    def need_resolve?
       @options[:resolve] && Time.now.to_i - @resolved_at > @options[:resolve]
     end
 
@@ -125,12 +126,20 @@ module RightSupport::Net
     # creation time; however, the ordering of the endpoints does not change thereafter
     # and the sequence is tried from the beginning for every request.
     #
+    # If you pass the :resolve option, then the list of endpoints is treated as a list
+    # of hostnames (or URLs containing hostnames) and the list is expanded out into a
+    # larger list with each hostname replaced by several entries, one for each of its IP
+    # addresses. If a single DNS hostname is associated with multiple A records, the
+    # :resolve option allows the balancer to treat each backing server as a distinct
+    # endpoint with its own health state, etc.
+    #
     # === Parameters
     # endpoints(Array):: a set of network endpoints (e.g. HTTP URLs) to be load-balanced
     #
     # === Options
     # retry:: a Class, array of Class or decision Proc to determine whether to keep retrying; default is to try all endpoints
     # fatal:: a Class, array of Class, or decision Proc to determine whether an exception is fatal and should not be retried
+    # resolve(Integer):: how often to re-resolve DNS hostnames of endpoints; default is nil (never resolve)
     # on_exception(Proc):: notification hook that accepts three arguments: whether the exception is fatal, the exception itself,
     #   and the endpoint for which the exception happened
     # health_check(Proc):: callback that allows balancer to check an endpoint health; should raise an exception if the endpoint
@@ -197,7 +206,8 @@ module RightSupport::Net
     # Return the first non-nil value provided by the block.
     def request
       raise ArgumentError, "Must call this method with a block" unless block_given?
-      if self.expired?
+
+      if need_resolve?
         @ips = self.resolve(@endpoints)
         @policy.set_endpoints(@ips)
       end

data/lib/right_support/net/s3_helper.rb

@@ -9,10 +9,12 @@
 # License Agreement between RightScale.com, Inc. and the licensee.
 
 module RightSupport::Net
-  # Class provides S3 functionality.
+  # Class that provides S3 functionality.
   # As part of RightSupport S3Helper does not include Rightscale::S3 and Encryptor modules.
   # This modules must be included in application.
   #
+  # @deprecated do not use; please use RightServices::Util::S3Storage instead!
+  #
   # Example:
   #
   # require 'right_support'

data/right_support.gemspec

@@ -7,8 +7,8 @@ spec = Gem::Specification.new do |s|
   s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
 
   s.name    = 'right_support'
-  s.version = '2.6.8'
-  s.date    = '2012-12-14'
+  s.version = '2.6.9'
+  s.date    = '2013-01-01'
 
   s.authors = ['Tony Spataro', 'Sergey Sergyenko', 'Ryan Williamson', 'Lee Kirchhoff', 'Sergey Enin', 'Alexey Karpik', 'Scott Messier']
   s.email   = 'support@rightscale.com'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: right_support
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: false
   segments: 
   - 2
   - 6
-  - 8
-  version: 2.6.8
+  - 9
+  version: 2.6.9
 platform: ruby
 authors: 
 - Tony Spataro
@@ -21,7 +21,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-12-14 00:00:00 -08:00
+date: 2013-01-01 00:00:00 -08:00
 default_executable: 
 dependencies: []