right_support 2.8.3 → 2.8.6

data/Gemfile

@@ -11,6 +11,7 @@ group :optional do
   gem "simple_uuid", "~> 0.2", :require => nil
   gem "uuid", "~> 2.3", :require => nil
   gem "yajl-ruby", "~> 1.1"
+  gem "iconv"
 end
 
 # Gems used during test and development of RightSupport.

data/Gemfile.lock

@@ -34,6 +34,7 @@ GEM
     gherkin (2.12.0)
       multi_json (~> 1.3)
     git (1.2.5)
+    iconv (1.0.4)
     jeweler (1.8.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
@@ -97,6 +98,7 @@ PLATFORMS
 DEPENDENCIES
   addressable (~> 2.2.7)
   flexmock (~> 1.0)
+  iconv
   jeweler (~> 1.8.3)
   net-ssh (~> 2.0)
   nokogiri (~> 1.5)

data/VERSION

@@ -1 +1 @@
-2.8.3
+2.8.6

data/features/serialization.feature

@@ -31,6 +31,14 @@ Feature: JSON serialization
     When I serialize a complex random data structure
     Then the serialized value should round-trip cleanly
 
+  Scenario Outline: Ruby string with non UTF-8 characters
+    When I serialize the Ruby value: <ruby>
+    Then the serialized value should be: <json>
+
+  Examples:
+    | ruby                                             | json                                             |
+    | "\xC0\xBCscript>\xC0\xBC/script>"                | "script>/script>"                                |
+
   Scenario Outline: object-escaped Symbol
     When I serialize the Ruby value: <ruby>
     Then the serialized value should be: <json>

data/lib/right_support/data/serializer.rb

@@ -145,8 +145,10 @@ module RightSupport::Data
     # @param [Object] object any Ruby object
     # @return [Object] JSONish representation of input object
     def object_to_jsonish(object)
+      iconv = Iconv.new('UTF-8//IGNORE', 'UTF-8')
       case object
       when String
+        object = iconv.iconv(object)
         if (object =~ /^:/ ) || (object =~ TIME_PATTERN)
           # Strings that look like a Symbol or Time must be object-escaped.
           {@marker => String.name,

data/lib/right_support/db/cassandra_model.rb

@@ -44,6 +44,40 @@ if require_succeeds?('cassandra/0.8')
       end
     end
 
+    # Monkey patch get_range_single so that it can return a array of key slices
+    # rather than converting it to a Hash
+    def get_range_single(column_family, options = {})
+      return_empty_rows = options.delete(:return_empty_rows) || false
+      slices_please = options.delete(:slices_not_hash) || false
+
+      column_family, _, _, options =
+        extract_and_validate_params(column_family, "", [options],
+                                    READ_DEFAULTS.merge(:start_key  => '',
+                                                        :finish_key => '',
+                                                        :key_count  => 100,
+                                                        :columns    => nil,
+                                                        :reversed   => false
+                                                       )
+                                   )
+
+      results = _get_range( column_family,
+                            options[:start_key].to_s,
+                            options[:finish_key].to_s,
+                            options[:key_count],
+                            options[:columns],
+                            options[:start].to_s,
+                            options[:finish].to_s,
+                            options[:count],
+                            options[:consistency],
+                            options[:reversed] )
+
+      unless slices_please
+        multi_key_slices_to_hash(column_family, results, return_empty_rows)
+      else
+        results
+      end
+    end
+
     # Monkey patch get_indexed_slices so that it returns OrderedHash, otherwise cannot determine
     # next start key when getting in chunks
     def get_indexed_slices(column_family, index_clause, *columns_and_options)
@@ -124,6 +158,16 @@ module RightSupport::DB
 
       METHODS_TO_LOG = [:multi_get, :get, :get_indexed_slices, :get_columns, :insert, :remove, 'multi_get', 'get', 'get_indexed_slices', 'get_columns', 'insert', 'remove']
 
+      #This is required to be overwritten in order to set the read CL
+      def default_read_consistency
+        nil
+      end
+
+      #This is required to be overwritten in order to set the write CL
+      def default_write_consistency
+        nil
+      end
+
       # Deprecate usage of CassandraModel under Ruby < 1.9
       def inherited(base)
         raise UnsupportedRubyVersion, "Support only Ruby >= 1.9" unless RUBY_VERSION >= "1.9"
@@ -229,6 +273,23 @@ module RightSupport::DB
           @@current_keyspace = nil
       end
 
+      def get_connection(current=nil)
+        config = env_config
+        thrift_client_options = {:timeout => RightSupport::DB::CassandraModel::DEFAULT_TIMEOUT}
+        thrift_client_options = {
+          :timeout => RightSupport::DB::CassandraModel::DEFAULT_TIMEOUT,
+          :server_retry_period => nil,
+        }
+
+        thrift_client_options.merge!({:protocol => Thrift::BinaryProtocolAccelerated}) if defined? Thrift::BinaryProtocolAccelerated
+
+        current ||= Cassandra.new(keyspace, config["server"], thrift_client_options)
+        current.disable_node_auto_discovery!
+        current.default_write_consistency = self.default_write_consistency if self.default_write_consistency
+        current.default_read_consistency = self.default_read_consistency if self.default_read_consistency
+        current
+      end
+
       # Client connected to Cassandra server
       # Create connection if does not already exist
       # Use BinaryProtocolAccelerated if it available
@@ -237,20 +298,7 @@ module RightSupport::DB
       # (Cassandra):: Client connected to server
       def conn()
         @@connections ||= {}
-
-        config = env_config
-
-        thrift_client_options = {
-          :timeout => RightSupport::DB::CassandraModel::DEFAULT_TIMEOUT,
-          :server_retry_period => nil,
-        }
-
-        if defined? Thrift::BinaryProtocolAccelerated
-          thrift_client_options.merge!({:protocol => Thrift::BinaryProtocolAccelerated})
-        end
-          
-        @@connections[self.keyspace] ||= Cassandra.new(self.keyspace, config["server"], thrift_client_options)
-        @@connections[self.keyspace].disable_node_auto_discovery!
+        @@connections[self.keyspace] = get_connection(@@connections[self.keyspace])
         @@connections[self.keyspace]
       end
 
@@ -371,48 +419,79 @@ module RightSupport::DB
       def stream_all_indexed_slices(index, key)
         expr = do_op(:create_idx_expr, index, key, "EQ")
 
-        start_row = ''
-        row_count = 10
-        has_more_rows = true
+        start_row		    = ''
+        max_row_count		    = 100
+        max_initial_column_count    = 1000 # number of columns to retrieve in the initial 2ndary index search
+        max_additional_column_count = 10000 # Number of columns to retrieve in a batch once we're targetting a single (long) row
 
+        # Loop over all CF rows, with batches of X
         while (start_row != nil)
-          clause = do_op(:create_idx_clause, [expr], start_row, row_count)
-
-          rows = self.conn.get_indexed_slices(column_family, clause, index,
-                                              :key_count => row_count,
-                                              :key_start => start_row)
-
-          rows = rows.keys
-          rows.shift unless start_row == ''
-          start_row = rows.last
-
-          rows.each do |row|
-            start_column = ''
-            column_count = 1_000
-            has_more_columns = true
-
-            while has_more_columns
-              clause = do_op(:create_idx_clause, [expr], row, 1)
-              chunk = self.conn.get_indexed_slices(column_family, clause, nil,
-                                                   :start => start_column,
-                                                   :count => column_count)
-
-              # Get first row's columns, because where are getting only one row [see clause, for more details]
-              key = chunk.keys.first
-              columns = chunk[key]
-
-              columns.shift unless start_column == ''
-              yield(key, columns) unless chunk.empty?
-
-              if columns.size >= column_count - 1
-                #Assume there are more columns, use last column as start of next slice
-                start_column = columns.last.column.name
-                column_count = 1_001
-              else
-                has_more_columns = false
+          clause = do_op(:create_idx_clause, [expr], start_row, max_row_count)
+
+          # Now, for each batch of rows, make sure don't ask for "ALL" columns of each row, to avoid hitting rows with a huge amount of columns, 
+          # which would cause large memory pressure here in the client, but more specially might cause long wait times and possible timeouts.
+          begin
+            rows = self.conn.get_indexed_slices(column_family, clause, :count => max_initial_column_count)
+          rescue Exception => e
+            wrapped_timeout      = e.is_a?(CassandraThrift::TimedOutException)
+            unwrapped_timeout    = e.is_a?(Thrift::TransportException) && (e.type == Thrift::TransportException::TIMED_OUT)
+            unwrapped_disconnect = e.is_a?(Thrift::TransportException) && (e.type == Thrift::TransportException::NOT_OPEN)
+
+            if (wrapped_timeout || unwrapped_timeout || unwrapped_disconnect) && (timeout_retries < retry_timeout)
+              timeout_retries += 1
+              retry
+            else
+              timeout_retries = 0
+              raise e
+            end
+          end
+
+          rows.each_pair do |row_key, columns|
+            # We already processed this row the previous iteration
+            next if row_key == start_row
+
+            yield(row_key, columns)
+
+            if columns.size >= max_initial_column_count
+              # Loop over all columns of the row (1000 at a time) starting at the last column name
+              last_column_name = columns.last.column.name
+              while( last_column_name != nil )
+                begin
+                  # Retrieve a slice of this row excluding the first column
+                  # as it's already been processed.
+                  more_cols = self.conn.get_range(
+                    column_family,
+                    :start_key => row_key,
+                    :finish_key => row_key,
+                    :count => max_additional_column_count,
+                    :start => last_column_name,
+                    :slices_not_hash => true ).first.columns[1..-1]
+                rescue Exception => e
+                  wrapped_timeout      = e.is_a?(CassandraThrift::TimedOutException)
+                  unwrapped_timeout    = e.is_a?(Thrift::TransportException) && (e.type == Thrift::TransportException::TIMED_OUT)
+                  unwrapped_disconnect = e.is_a?(Thrift::TransportException) && (e.type == Thrift::TransportException::NOT_OPEN)
+
+                  if (wrapped_timeout || unwrapped_timeout || unwrapped_disconnect) && (timeout_retries < retry_timeout)
+                    timeout_retries += 1
+                    retry
+                  else
+                    timeout_retries = 0
+                    raise e
+                  end
+                end
+
+                yield(row_key, more_cols)
+                if more_cols.size < max_additional_column_count
+                    last_column_name = nil
+                else
+                    last_column_name = more_cols.last.column.name
+                end
               end
             end
           end
+
+          break if rows.size < max_row_count
+          start_row = rows.keys.last
         end
       end
 
@@ -573,17 +652,8 @@ module RightSupport::DB
       # === Return
       # true:: Always return true
       def reconnect
-        config = env_config
-
         return false if keyspace.nil?
-
-        thrift_client_options = {:timeout => RightSupport::DB::CassandraModel::DEFAULT_TIMEOUT}
-        thrift_client_options.merge!({:protocol => Thrift::BinaryProtocolAccelerated})\
-          if defined? Thrift::BinaryProtocolAccelerated
-
-        connection = Cassandra.new(keyspace, config["server"], thrift_client_options)
-        connection.disable_node_auto_discovery!
-        @@connections[keyspace] = connection
+        @@connections[keyspace] = get_connection
         true
       end
 

data/lib/right_support/net/dns.rb

@@ -20,17 +20,99 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+require 'ipaddr'
 require 'socket'
 require 'uri'
 
 module RightSupport::Net
+
+  # IPAddr does not support returning a block of addresses in CIDR notation.
+  class IPNet < ::IPAddr
+    def cidr_block
+      # Ruby Math:: does not have a log2() function :(
+      cidr_block = 32 - (Math.log(self.to_range.count) / Math.log(2)).to_i
+    end
+
+    # Don't want to override to_s here since we also
+    # use this during URI transformation and need a way
+    # to get the raw dotted-quad address
+    #
+    def to_cidr
+      "#{self.to_s}/#{self.cidr_block}"
+    end
+  end
+
+  # A ResolvedEndpoint represents the resolution of a host which can contain
+  # multiple IP addresses or entire IP address ranges of varying size.
+  class ResolvedEndpoint
+    attr_accessor :uri
+
+    def initialize(ips, opts={})
+      @ip_addresses = []
+      @uri = opts[:uri]
+
+      ips.to_a.each do |address|
+        @ip_addresses << IPNet.new(address)
+      end
+
+      unless self.all_hosts? || @uri == nil
+        raise URI::InvalidURIError, "Cannot resolve URI with CIDR block bigger than a single host" unless self.all_hosts?
+      end
+    end
+
+    def addresses()
+      @ip_addresses.map do |addr|
+        if addr.to_range.count == 1 && @uri != nil
+            transformed_uri = uri.dup
+            transformed_uri.host = addr.to_s
+            transformed_uri.to_s
+        else
+          addr
+        end
+      end
+    end
+    alias addrs :addresses
+
+    def blocks()
+      @ip_addresses.map {|addr| addr.to_cidr}
+    end
+
+    def all_hosts?()
+      @ip_addresses.all? {|addr| addr.to_range.count == 1}
+    end
+
+    def ==(another_endpoint)
+      another_endpoint.addresses.all? {|addr| addresses.member? addr } && another_endpoint.uri == @uri
+    end
+  end
+
   module DNS
     DEFAULT_RESOLVE_OPTIONS = {
       :address_family => Socket::AF_INET,
       :socket_type    => Socket::SOCK_STREAM,
       :protocol       => Socket::IPPROTO_TCP,
-      :retry          => 3
-    }
+      :retry          => 3,
+      :uri            => nil,
+    }.freeze
+
+    STATIC_HOSTNAME_TRANSLATIONS = {
+      # This list of CIDR blocks comes directly from Amazon and
+      # can be found here: https://forums.aws.amazon.com/ann.jspa?annID=2051
+      'cf-mirror.rightscale.com' => [ '54.192.0.0/16',
+                                      '54.230.0.0/16',
+                                      '54.239.128.0/18',
+                                      '54.240.128.0/18',
+                                      '204.246.164.0/22',
+                                      '204.246.168.0/22',
+                                      '204.246.174.0/23',
+                                      '204.246.176.0/20',
+                                      '205.251.192.0/19',
+                                      '205.251.249.0/24',
+                                      '205.251.250.0/23',
+                                      '205.251.252.0/23',
+                                      '205.251.254.0/24',
+                                      '216.137.32.0/19' ],
+    }.freeze
 
     # Resolve a set of DNS hostnames to the individual IP addresses to which they map. Only handles
     # IPv4 addresses.
@@ -81,10 +163,37 @@ module RightSupport::Net
     # @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={})
-      resolved_hostnames = resolve_with_hostnames(endpoints, opts)
+      opts = DEFAULT_RESOLVE_OPTIONS.merge(opts)
+      endpoints = Array(endpoints)
+
+      retries = 0
       resolved_endpoints = []
-      resolved_hostnames.each_value{ |v| resolved_endpoints.concat(v) }
-      return resolved_endpoints
+
+      endpoints.each do |endpoint|
+        begin
+          resolved_endpoint = nil
+          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
+
+            resolved_endpoint = resolve_endpoint(hostname, opts.merge(:uri=>uri))
+          else
+            resolved_endpoint = resolve_endpoint(endpoint, opts)
+          end
+          resolved_endpoints << resolved_endpoint
+        rescue SocketError => e
+          retries += 1
+          if retries < opts[:retry]
+            retry
+          else
+            raise
+          end
+        end
+      end
+
+      resolved_endpoints
     end
 
     # Similar to resolve, but return a hash of { hostnames => [endpoints] }
@@ -113,52 +222,44 @@ module RightSupport::Net
     # @raise URI::InvalidURIError if endpoints contains an invalid or URI
     # @raise SocketError if endpoints contains an invalid or unresolvable hostname
     def self.resolve_with_hostnames(endpoints, opts={})
-      opts = DEFAULT_RESOLVE_OPTIONS.merge(opts)
-      endpoints = [endpoints] unless endpoints.respond_to?(:each)
-
       hostname_hash = {}
-      retries = 0
-
-      endpoints.each do |endpoint|
-        begin
-          resolved_endpoints = []
-          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
+      endpoints.each {|endpoint| hostname_hash[endpoint] = resolve(endpoint, opts).first}
+      hostname_hash
+    end
 
-            infos = Socket.getaddrinfo(hostname, nil,
-                                       opts[:address_family], opts[:socket_type], opts[:protocol])
+    private
 
-            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
-          hostname_hash[endpoint.to_s] = resolved_endpoints
-        rescue SocketError => e
-          retries += 1
-          if retries < opts[:retry]
-            retry
-          else
-            raise
-          end
-        end
+    # Lookup the address(es) associated with the given endpoints.
+    #
+    # Perform an address lookup in this order:
+    #   1. Hardcoded translation table.
+    #   2. System address lookup (e.g. DNS, hosts files...etc)
+    #
+    # Although this method does accept IPv4 dotted-quad addresses as input, it does not accept
+    # IPv6 addresses. However, given hostnames 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 [String] endpoint as a hostname or IPv4 address
+    # @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>] List of resolved IPv4/IPv6 addresses.
+    #
+    # @raise SocketError if endpoints contains an invalid or unresolvable hostname
+    def self.resolve_endpoint(endpoint, opts=DEFAULT_RESOLVE_OPTIONS)
+      if STATIC_HOSTNAME_TRANSLATIONS.has_key?(endpoint)
+        ResolvedEndpoint.new(STATIC_HOSTNAME_TRANSLATIONS[endpoint], opts)
+      else
+        infos = Socket.getaddrinfo(endpoint, nil,
+                                   opts[:address_family], opts[:socket_type], opts[:protocol])
+        ResolvedEndpoint.new(infos.map { |info| info[3] }, opts)
       end
-
-      hostname_hash
     end
-
   end
 end
 

data/lib/right_support/net/http_client.rb

@@ -151,6 +151,10 @@ module RightSupport::Net
       request(:delete, *args)
     end
 
+    def patch(*args)
+      request(:patch, *args)
+    end
+
   # A very thin wrapper around RestClient::Request.execute.
   #
   # === Parameters

data/lib/right_support/net/request_balancer.rb

@@ -204,7 +204,7 @@ module RightSupport::Net
     # === Return
     # Return the first hostname that resolved to the IP (there should only ever be one)
     def lookup_hostname(endpoint)
-      @resolved_hostnames.select{ |k,v| v.include?(endpoint) }.shift[0]
+      @resolved_hostnames.select{ |k,v| v.addresses.include?(endpoint) }.shift[0]
     end
 
     # Perform a request.
@@ -369,7 +369,7 @@ module RightSupport::Net
     def resolve
       @resolved_hostnames = RightSupport::Net::DNS.resolve_with_hostnames(@endpoints)
       resolved_endpoints = []
-      @resolved_hostnames.each_value{ |v| resolved_endpoints.concat(v) }
+      @resolved_hostnames.each_value{ |v| resolved_endpoints.concat(v.addrs.map {|addr| addr.to_s}) }
       logger.info("RequestBalancer: resolved #{@endpoints.inspect} to #{resolved_endpoints.inspect}") if resolved_endpoints != @ips
       @ips = resolved_endpoints
       @policy.set_endpoints(@ips)

data/right_support.gemspec

@@ -4,14 +4,14 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{right_support}
-  s.version = "2.8.3"
+  s.name = "right_support"
+  s.version = "2.8.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tony Spataro", "Sergey Sergyenko", "Ryan Williamson", "Lee Kirchhoff", "Alexey Karpik", "Scott Messier"]
-  s.date = %q{2013-10-03}
-  s.description = %q{A toolkit of useful, reusable foundation code created by RightScale.}
-  s.email = %q{support@rightscale.com}
+  s.date = "2013-12-18"
+  s.description = "A toolkit of useful, reusable foundation code created by RightScale."
+  s.email = "support@rightscale.com"
   s.extra_rdoc_files = [
     "LICENSE",
     "README.rdoc"
@@ -136,14 +136,13 @@ Gem::Specification.new do |s|
     "spec/validation/openssl_spec.rb",
     "spec/validation/ssh_spec.rb"
   ]
-  s.homepage = %q{https://github.com/rightscale/right_support}
+  s.homepage = "https://github.com/rightscale/right_support"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Reusable foundation code.}
+  s.rubygems_version = "1.8.15"
+  s.summary = "Reusable foundation code."
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

data/spec/db/cassandra_model_part1_spec.rb

@@ -58,14 +58,14 @@ describe RightSupport::DB::CassandraModel do
      ,'ring1, ring2, ring3' => ['ring1', 'ring2', 'ring3'] \
      ,['ring1', 'ring2', 'ring3'] => ['ring1', 'ring2', 'ring3']
     }.each do |config_string, congig_test|
-      it "shoudl successfully intialize from #{config_string.inspect}" do
+      it "should successfully intialize from #{config_string.inspect}" do
 
 
         old_rack_env = ENV['RACK_ENV']
         begin
           ENV['RACK_ENV'] = env
 
-          flexmock(Cassandra).should_receive(:new).with(/#{default_keyspace}_#{env}/, congig_test , {:timeout=>10}).and_return(default_keyspace_connection)
+          flexmock(Cassandra).should_receive(:new).with(/#{default_keyspace}_#{env}/, congig_test , {:timeout=>10, :server_retry_period=>nil}).and_return(default_keyspace_connection)
           default_keyspace_connection.should_receive(:disable_node_auto_discovery!).and_return(true)
         
 
@@ -81,4 +81,4 @@ describe RightSupport::DB::CassandraModel do
       end
     end
   end
-end
+end

data/spec/net/dns_spec.rb

@@ -22,7 +22,7 @@ describe RightSupport::Net::DNS do
   context :resolve do
     context 'given default :retry => 3' do
       let(:endpoint) { 'www.example.com' }
-      let(:output) { ['1.1.1.1', '2.2.2.2'] }
+      let(:output) { [RightSupport::Net::ResolvedEndpoint.new(['1.1.1.1', '2.2.2.2'])] }
 
       it 'retries SocketError' do
         mock_getaddrinfo('www.example.com', SocketError)
@@ -55,7 +55,7 @@ describe RightSupport::Net::DNS do
     context 'given various endpoint formats' do
       context 'e.g. a DNS hostname' do
         let(:endpoint) { 'www.example.com' }
-        let(:output) { ['1.1.1.1', '2.2.2.2'] }
+        let(:output) { [RightSupport::Net::ResolvedEndpoint.new(['1.1.1.1', '2.2.2.2'])] }
 
         it 'resolves to IP addresses' do
           mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
@@ -65,7 +65,7 @@ describe RightSupport::Net::DNS do
 
       context 'e.g. an IPv4 address' do
         let(:endpoint) { '127.0.0.1' }
-        let(:output) { ['127.0.0.1'] }
+        let(:output) { [RightSupport::Net::ResolvedEndpoint.new(['127.0.0.1'])] }
 
         it 'resolves to the same address' do
           mock_getaddrinfo('127.0.0.1', ['127.0.0.1'])
@@ -79,7 +79,7 @@ describe RightSupport::Net::DNS do
 
         it 'resolves to URLs with addresses substituted' do
           mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
-          subject.resolve(endpoint).should == output
+          subject.resolve(endpoint).first.addrs.should == output
         end
 
         context 'with a path component' do
@@ -88,7 +88,7 @@ describe RightSupport::Net::DNS do
 
           it 'resolves to URLs with path component preserved' do
             mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
-            subject.resolve(endpoint).should == output
+            subject.resolve(endpoint).first.addrs.should == output
           end
         end
       end
@@ -111,13 +111,13 @@ describe RightSupport::Net::DNS do
 
       context 'e.g. several hostnames' do
         let(:endpoints) { ['www.example.com', 'www.example.net'] }
-        let(:output) { ['1.1.1.1', '2.2.2.2', '3.3.3.3', '4.4.4.4'] }
+        let(:output) { [RightSupport::Net::ResolvedEndpoint.new(['1.1.1.1', '2.2.2.2']), RightSupport::Net::ResolvedEndpoint.new(['3.3.3.3', '4.4.4.4'])] }
 
         it 'resolves to IP addresses' do
           mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
           mock_getaddrinfo('www.example.net', ['3.3.3.3', '4.4.4.4'])
 
-          subject.resolve(endpoints).sort.should == output
+          subject.resolve(endpoints).should == output
         end
       end
 
@@ -129,7 +129,42 @@ describe RightSupport::Net::DNS do
           mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
           mock_getaddrinfo('www.example.net', ['3.3.3.3', '4.4.4.4'])
 
-          subject.resolve(endpoints).sort.should == output.sort
+          subject.resolve(endpoints).map {|ep| ep.addrs}.flatten == output
+        end
+      end
+    end
+
+    context 'requesting CIDR blocks' do
+      context 'DNS resolvable addresses' do
+        let(:endpoint) { 'www.example.com' }
+        let(:output) { ['1.1.1.1/32', '2.2.2.2/32'] }
+
+        it 'resolves hostname to CIDR /32 blocks' do
+          mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
+          subject.resolve(endpoint).first.blocks.should == output
+        end
+
+        it 'resolves IP addresses to CIDR /32 blocks' do
+          mock_getaddrinfo('1.1.1.1', ['1.1.1.1'])
+          mock_getaddrinfo('2.2.2.2', ['2.2.2.2'])
+          subject.resolve(['1.1.1.1', '2.2.2.2']).map {|endpoint| endpoint.blocks}.flatten.should =~ output
+        end
+
+        it 'refuses to resolve a URI having a CIDR block < /32' do
+          lambda do
+            subject.resolve("http://cf-mirror.rightscale.com")
+          end.should raise_error(URI::InvalidURIError)
+        end
+      end
+
+      context 'Static CIDR blocks' do
+        let(:endpoint) { 'cf-mirror.rightscale.com' }
+
+        it 'resolves hostname to static CIDR blocks' do
+          subject.resolve(endpoint).first.blocks.each do |addr|
+            # Addresses should all be in CIDR form and not single /32 addresses
+            addr.should =~ /^\d+(?:\.\d+){3}\/(?:#{1.upto(31).to_a.join('|')})$/
+          end
         end
       end
     end
@@ -138,8 +173,8 @@ describe RightSupport::Net::DNS do
   context :resolve_with_hostnames do
     context 'given common inputs' do
       let(:endpoints) { ['www.example1.com','www.example2.com'] }
-      let(:output) { {'www.example1.com'=>['1.1.1.1', '2.2.2.2'],
-                      'www.example2.com'=>['3.3.3.3', '4.4.4.4']} }
+      let(:output) { {'www.example1.com'=>RightSupport::Net::ResolvedEndpoint.new(['1.1.1.1', '2.2.2.2']),
+                      'www.example2.com'=>RightSupport::Net::ResolvedEndpoint.new(['3.3.3.3', '4.4.4.4'])} }
 
       it 'resolves to IP addresses' do
         mock_getaddrinfo('www.example1.com', ['1.1.1.1', '2.2.2.2'])

data/spec/net/request_balancer_spec.rb

@@ -91,6 +91,10 @@ describe RightSupport::Net::RequestBalancer do
     @health_checks.should == expect * (yellow_states - 1)
   end
 
+  def make_endpoint(addresses)
+    RightSupport::Net::ResolvedEndpoint.new(addresses)
+  end
+
   context :initialize do
     it 'requires a list of endpoint URLs' do
       lambda do
@@ -267,7 +271,7 @@ describe RightSupport::Net::RequestBalancer do
     context 'with :resolve option' do
       before(:each) do
         flexmock(RightSupport::Net::DNS).should_receive(:resolve_with_hostnames).
-            with(['host1', 'host2']).and_return({'host1' => ['1.1.1.1', '2.2.2.2'], 'host2' => ['3.3.3.3']})
+            with(['host1', 'host2']).and_return({'host1' => make_endpoint(['1.1.1.1', '2.2.2.2']), 'host2' => make_endpoint(['3.3.3.3'])})
         @balancer = RightSupport::Net::RequestBalancer.new(['host1', 'host2'], :resolve => 15)
       end
 
@@ -482,10 +486,10 @@ describe RightSupport::Net::RequestBalancer do
     context 'with :resolve option' do
       before(:each) do
         @endpoints = ['host1', 'host2', 'host3', 'host4']
-        @resolved_set_1 = {'host1' => ['1.1.1.1', '2.2.2.2', '3.3.3.3', '4.4.4.4']}
-        @resolved_set_2 = {'host1'=>['5.5.5.5'],'host2'=>['6.6.6.6'],'host3'=>['7.7.7.7'],'host4'=>['8.8.8.8']}
+        @resolved_set_1 = {'host1' => make_endpoint(['1.1.1.1', '2.2.2.2', '3.3.3.3', '4.4.4.4'])}
+        @resolved_set_2 = {'host1'=> make_endpoint(['5.5.5.5']),'host2'=>make_endpoint(['6.6.6.6']),'host3'=>make_endpoint(['7.7.7.7']),'host4'=>make_endpoint(['8.8.8.8'])}
         @resolved_set_2_array = []
-        @resolved_set_2.each_value{ |v| @resolved_set_2_array.concat(v) }
+        @resolved_set_2.each_value{ |v| @resolved_set_2_array.concat(v.addrs) }
         @dns = flexmock(RightSupport::Net::DNS)
       end
 
@@ -495,7 +499,7 @@ describe RightSupport::Net::RequestBalancer do
 
         @rb.request { true }
         @policy = @rb.instance_variable_get("@policy")
-        @resolved_set_1['host1'].include?(@policy.next.first).should be_true
+        @resolved_set_1['host1'].addrs.include?(@policy.next.first).should be_true
       end
 
       it 're-resolves list of ip addresses if TTL is expired' do
@@ -504,7 +508,7 @@ describe RightSupport::Net::RequestBalancer do
 
         @rb.request { true }
         @policy = @rb.instance_variable_get("@policy")
-        @resolved_set_1['host1'].include?(@policy.next.first).should be_true
+        @resolved_set_1['host1'].addrs.include?(@policy.next.first).should be_true
 
         @rb.instance_variable_set("@resolved_at", Time.now.to_i - 16)
         @rb.request { true }

data/spec/stats/helpers_spec.rb

@@ -431,7 +431,7 @@ describe RightSupport::Stats do
               "/opt/rightscale/right_link/common/lib/common/serializer.rb:133:in `cascade_serializers'"}]}}
       RightSupport::Stats.exceptions_str(exceptions, "").should ==
           "receive total: 2, most recent:\n" +
-          "(2) Sun Aug 11 15:26:19 RightScale::Serializer::SerializationError: Could not \n" +
+          "(2) #{Time.at(exceptions['receive']['recent'].first['when']).strftime("%a %b %d %H:%M:%S")} RightScale::Serializer::SerializationError: Could not \n" +
           "    load packet using [RightScale::SecureSerializer] (Failed to load with \n" +
           "    RightScale::SecureSerializer (TypeError: can't convert nil into String in /opt/\n" +
           "    rightscale/right_link/common/lib/common/security/signature.rb:56:in \n" +

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: right_support
 version: !ruby/object:Gem::Version 
-  hash: 41
-  prerelease: false
+  hash: 35
+  prerelease: 
   segments: 
   - 2
   - 8
-  - 3
-  version: 2.8.3
+  - 6
+  version: 2.8.6
 platform: ruby
 authors: 
 - Tony Spataro
@@ -20,8 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-10-21 00:00:00 -07:00
-default_executable: 
+date: 2013-12-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
@@ -34,10 +33,10 @@ dependencies:
         - 0
         - 9
         version: "0.9"
-  requirement: *id001
   type: :development
-  name: rake
+  requirement: *id001
   prerelease: false
+  name: rake
 - !ruby/object:Gem::Dependency 
   version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -50,10 +49,10 @@ dependencies:
         - 8
         - 3
         version: 1.8.3
-  requirement: *id002
   type: :development
-  name: jeweler
+  requirement: *id002
   prerelease: false
+  name: jeweler
 - !ruby/object:Gem::Dependency 
   version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -65,10 +64,10 @@ dependencies:
         - 1
         - 0
         version: "1.0"
-  requirement: *id003
   type: :development
-  name: right_develop
+  requirement: *id003
   prerelease: false
+  name: right_develop
 - !ruby/object:Gem::Dependency 
   version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
@@ -80,10 +79,10 @@ dependencies:
         - 0
         - 10
         version: "0.10"
-  requirement: *id004
   type: :development
-  name: ruby-debug
+  requirement: *id004
   prerelease: false
+  name: ruby-debug
 - !ruby/object:Gem::Dependency 
   version_requirements: &id005 !ruby/object:Gem::Requirement 
     none: false
@@ -96,10 +95,10 @@ dependencies:
         - 11
         - 6
         version: 0.11.6
-  requirement: *id005
   type: :development
-  name: ruby-debug19
+  requirement: *id005
   prerelease: false
+  name: ruby-debug19
 - !ruby/object:Gem::Dependency 
   version_requirements: &id006 !ruby/object:Gem::Requirement 
     none: false
@@ -112,10 +111,10 @@ dependencies:
         - 4
         - 2
         version: 2.4.2
-  requirement: *id006
   type: :development
-  name: rdoc
+  requirement: *id006
   prerelease: false
+  name: rdoc
 - !ruby/object:Gem::Dependency 
   version_requirements: &id007 !ruby/object:Gem::Requirement 
     none: false
@@ -127,10 +126,10 @@ dependencies:
         - 1
         - 0
         version: "1.0"
-  requirement: *id007
   type: :development
-  name: flexmock
+  requirement: *id007
   prerelease: false
+  name: flexmock
 - !ruby/object:Gem::Dependency 
   version_requirements: &id008 !ruby/object:Gem::Requirement 
     none: false
@@ -143,10 +142,10 @@ dependencies:
         - 0
         - 0
         version: 1.0.0
-  requirement: *id008
   type: :development
-  name: syntax
+  requirement: *id008
   prerelease: false
+  name: syntax
 - !ruby/object:Gem::Dependency 
   version_requirements: &id009 !ruby/object:Gem::Requirement 
     none: false
@@ -158,10 +157,10 @@ dependencies:
         - 1
         - 5
         version: "1.5"
-  requirement: *id009
   type: :development
-  name: nokogiri
+  requirement: *id009
   prerelease: false
+  name: nokogiri
 description: A toolkit of useful, reusable foundation code created by RightScale.
 email: support@rightscale.com
 executables: []
@@ -290,7 +289,6 @@ files:
 - spec/stats/helpers_spec.rb
 - spec/validation/openssl_spec.rb
 - spec/validation/ssh_spec.rb
-has_rdoc: true
 homepage: https://github.com/rightscale/right_support
 licenses: 
 - MIT
@@ -320,7 +318,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Reusable foundation code.