right_support 0.9.9 → 1.0.4

data/README.rdoc

@@ -65,17 +65,20 @@ any exceptions. (NB: a nil return value counts as success!!) If you specify that
 certain class of exception is "fatal," then that exception will cause REST to re-
 raise immediately
 
-== HTTP REST Client
+== HTTPClient
 
 We provide a very thin wrapper around the rest-client gem that enables simple but
 robust rest requests with a timeout, headers, etc.
 
-The RightSupport::Net::REST module is interface-compatible with the RestClient
+The HTTPClient is interface-compatible with the RestClient
 module, but allows an optional timeout to be specified as an extra parameter.
-
+   
+   # Create a wrapper's object
+   @client = RightSupport::Net::HTTPClient.new
+   
    # Default timeout is 5 seconds
-   RightSupport::Net::REST.get('http://localhost')
+   @client.get('http://localhost')
 
-   # Make sure the REST request fails after 1 second so we can report an error
+   # Make sure the HTTPClient request fails after 1 second so we can report an error
    # and move on!
-   RightSupport::Net::REST.get('http://localhost', {'X-Hello'=>'hi!'}, 1)
+   @client.get('http://localhost', {:headers => {'X-Hello'=>'hi!'}, :timeout => 1)}

data/lib/right_support/db/cassandra_model.rb

@@ -32,7 +32,7 @@ module RightSupport::DB
         return @@conn if @@conn
 
         config = @@config[ENV["RACK_ENV"]]
-        @@conn = Cassandra.new(keyspace, config["server"],{:timeout => RightSupport::CassandraModel::DEFAULT_TIMEOUT})
+        @@conn = Cassandra.new(keyspace, config["server"],{:timeout => RightSupport::DB::CassandraModel::DEFAULT_TIMEOUT})
         @@conn.disable_node_auto_discovery!
         @@conn
       end

data/lib/right_support/net/balancing/health_check.rb

@@ -0,0 +1,124 @@
+#
+# Copyright (c) 2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# 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 'set'
+
+module RightSupport::Net::Balancing
+  
+  class EndpointsStack
+
+    # Modified by Ryan Williamson on 9/28/2011 to ensure default values exist
+    # for @yellow_states and @reset_time
+    DEFAULT_YELLOW_STATES = 4
+    DEFAULT_RESET_TIME    = 300
+
+    def initialize(endpoints, yellow_states=nil, reset_time=nil)
+      @endpoints = Hash.new
+      @yellow_states = yellow_states || DEFAULT_YELLOW_STATES
+      @reset_time = reset_time || DEFAULT_RESET_TIME
+      endpoints.each { |ep| @endpoints[ep] = {:n_level => 0,:timestamp => 0 }}
+    end
+    
+    def sweep
+      @endpoints.each { |k,v| decrease_state(k,0,Time.now) if Float(Time.now - v[:timestamp]) > @reset_time }
+    end
+    
+    def sweep_and_return_yellow_and_green
+      sweep
+      @endpoints.select { |k,v| v[:n_level] < @yellow_states }
+    end
+    
+    def decrease_state(endpoint,t0,t1)
+      unless @endpoints[endpoint][:n_level] == 0
+        @endpoints[endpoint][:n_level]    -= 1
+        @endpoints[endpoint][:timestamp]  = t1
+      end
+    end
+    
+    def increase_state(endpoint,t0,t1)
+      unless @endpoints[endpoint][:n_level] == @yellow_states
+        @endpoints[endpoint][:n_level]    += 1
+        @endpoints[endpoint][:timestamp]  = t1
+      end
+    end
+    
+  end
+  
+  # Implementation concepts: endpoints have three states, red, yellow and green.  Yellow
+  # has several levels (@yellow_states) to determine the health of the endpoint. The
+  # balancer works by avoiding "red" endpoints and retrying them after awhile.  Here is a
+  # brief description of the state transitions:
+  # * green: last request was successful.
+  #    * on success: remain green
+  #    * on failure: change state to yellow and set it's health to healthiest (1)
+  # * red: skip this server
+  #    * after @reset_time passes change state to yellow and set it's health to
+  #      sickest (@yellow_states)
+  # * yellow: last request was either successful or failed
+  #    * on success: change state to green if it's health was healthiest (1), else
+  #      retain yellow state and improve it's health
+  #    * on failure: change state to red if it's health was sickest (@yellow_states), else
+  #      retain yellow state and decrease it's health
+
+  class HealthCheck
+    
+    def initialize(endpoints,options = {})
+      # Modified by Ryan Williamson on 9/27/2011
+      # Previously if you created an instance of HealthCheck without the required options
+      # they would get passed as nil and overwrite EndpointsStack's default options causing an ArgumentError
+      yellow_states = options[:yellow_states]
+      reset_time = options[:reset_time]
+      # End modification
+      @health_check = options.delete(:health_check)
+
+      @stack = EndpointsStack.new(endpoints,yellow_states,reset_time)
+      @counter = rand(0xffff)
+    end
+
+    def next
+      # Returns the array of hashes which consists of yellow and green endpoints with the 
+      # following structure: [ [EP1, {:n_level => ..., :timestamp => ... }], [EP2, ... ] ]
+      endpoints = @stack.sweep_and_return_yellow_and_green
+      return nil if endpoints.empty?
+      
+      # Selection of the next endpoint using RoundRobin
+      @counter += 1
+      i = @counter % endpoints.size      
+      
+      # Returns false or true, depending on whether EP is yellow or not
+      [ endpoints[i][0], endpoints[i][1][:n_level] != 0 ]
+    end
+
+    def good(endpoint, t0, t1)
+      @stack.decrease_state(endpoint,t0,t1)
+    end
+
+    def bad(endpoint, t0, t1)
+      @stack.increase_state(endpoint,t0,t1)
+    end
+    
+    def health_check(endpoint)
+      @stack.increase_state(endpoint,t0,Time.now) unless @health_check.call(endpoint)      
+    end
+    
+  end
+end

data/lib/right_support/net/balancing/round_robin.rb

@@ -0,0 +1,43 @@
+#
+# Copyright (c) 2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightSupport::Net::Balancing
+  class RoundRobin
+    def initialize(endpoints,options ={})
+      @endpoints = endpoints
+      @counter = rand(0xffff)
+    end
+
+    def next
+      @counter += 1
+      [ @endpoints[@counter % @endpoints.size], false ]
+    end
+
+    def good(endpoint, t0, t1)
+      #no-op; round robin does not care about failures
+    end
+
+    def bad(endpoint, t0, t1)
+      #no-op; round robin does not care about failures
+    end
+  end
+end

data/lib/right_support/net/balancing.rb

@@ -0,0 +1,33 @@
+#
+# Copyright (c) 2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#
+# A namespace to hold load-balancing policies to be used with RequestBalancer
+# and potentially other networking classes.
+#
+module RightSupport::Net::Balancing
+
+end
+
+Dir[File.expand_path('../balancing/*.rb', __FILE__)].each do |filename|
+  require filename
+end

data/lib/right_support/net/http_client.rb

@@ -0,0 +1,98 @@
+module RightSupport::Net
+  if_require_succeeds('right_http_connection') do
+    #nothing, nothing at all! just need to make sure
+    #that RightHttpConnection gets loaded before
+    #rest-client, so the Net::HTTP monkey patches
+    #take effect.
+  end
+
+  if_require_succeeds('restclient') do
+    HAS_REST_CLIENT = true
+  end
+
+  # Raised to indicate that no suitable provider of REST/HTTP services was found. Since RightSupport's
+  # REST support is merely a wrapper around other libraries, it cannot work in isolation. See the REST
+  # module for more information about supported providers.
+  class NoProvider < Exception; end
+  
+  #
+  # A wrapper for the rest-client gem that provides timeouts and other useful features while preserving
+  # the simplicity and ease of use of RestClient's simple, static (class-level) interface.
+  #
+  # Even though this code relies on RestClient, the right_support gem does not depend on the rest-client
+  # gem because not all users of right_support will want to make use of this interface. If one of HTTPClient
+  # instance's method is called and RestClient is not available, an exception will be raised.
+  #
+  #
+  # HTTPClient supports a subset of the module methods provided by RestClient and is interface-compatible
+  # with those methods it replaces; the only difference is that the HTTPClient version of each method accepts an
+  # additional, optional parameter which is a request timeout in seconds. The RestClient gem does not allow
+  # timeouts without instantiating a "heavyweight" HTTPClient object.
+  #
+  #   # create an instance ot HTTPClient
+  #   @client = HTTPClient.new()
+  #
+  #   # GET
+  #   xml = @client.get 'http://example.com/resource'
+  #   # and, with timeout of 5 seconds...
+  #   jpg = @client.get 'http://example.com/resource', {:accept => 'image/jpg', :timeout => 5}
+  #
+  #   # authentication and SSL
+  #   @client.get 'https://user:password@example.com/private/resource'
+  #
+  #   # POST or PUT with a hash sends parameters as a urlencoded form body
+  #   @client.post 'http://example.com/resource', {:param1 => 'one'}
+  #
+  #   # nest hash parameters, add a timeout of 10 seconds (and specify "no extra headers")
+  #   @client.post 'http://example.com/resource', {:payload => {:nested => {:param1 => 'one'}}, :timeout => 10}
+  #
+  #   # POST and PUT with raw payloads
+  #   @client.post 'http://example.com/resource', {:payload => 'the post body', :headers => {:content_type => 'text/plain'}}
+  #   @client.post 'http://example.com/resource.xml', {:payload => xml_doc}
+  #   @client.put 'http://example.com/resource.pdf', {:payload => File.read('my.pdf'), :headers => {:content_type => 'application/pdf'}}
+  #
+  #   # DELETE
+  #   @client.delete 'http://example.com/resource'
+  #
+  #   # retrieve the response http code and headers
+  #   res = @client.get 'http://example.com/some.jpg'
+  #   res.code                    # => 200
+  #   res.headers[:content_type]  # => 'image/jpg'
+  class HTTPClient
+    
+    DEFAULT_TIMEOUT       = 5
+    DEFAULT_OPEN_TIMEOUT  = 2
+    
+    def initialize(options = {})
+      [:get, :post, :put, :delete].each do |method|
+         define_instance_method(method) {|*args| query(method, *args)}
+      end
+    end
+
+    protected
+    
+    # Helps to add default methods to class
+    def define_instance_method(method, &block)
+      (class << self; self; end).module_eval do
+        define_method(method, &block)
+      end
+    end
+      
+    def query(type, url, options={}, &block)
+      options[:timeout]       ||= DEFAULT_TIMEOUT
+      options[:open_timeout]  ||= DEFAULT_OPEN_TIMEOUT
+      options[:headers]       ||= {}
+      options.merge!(:method => type, :url => url)
+      request(options, &block)
+    end
+
+    # Wrapper around RestClient::Request.execute -- see class documentation for details.
+    def request(options, &block)
+      if HAS_REST_CLIENT
+        RestClient::Request.execute(options, &block)
+      else
+        raise NoProvider, "Cannot find a suitable HTTP client library"
+      end
+    end
+  end# HTTPClient
+end

data/lib/right_support/net/request_balancer.rb

@@ -2,11 +2,15 @@ module RightSupport::Net
   # Raised to indicate the (uncommon) error condition where a RequestBalancer rotated
   # through EVERY URL in a list without getting a non-nil, non-timeout response. 
   class NoResult < Exception; end
-
+  
   # Utility class that allows network requests to be randomly distributed across
   # a set of network endpoints. Generally used for REST requests by passing an
   # Array of HTTP service endpoint URLs.
   #
+  # Note that this class also serves as a namespace for endpoint selection policies,
+  # which are classes that actually choose the next endpoint based on some criterion
+  # (round-robin, health of endpoint, response time, etc).
+  #
   # The balancer does not actually perform requests by itself, which makes this
   # class usable for various network protocols, and potentially even for non-
   # networking purposes. The block does all the work; the balancer merely selects
@@ -18,6 +22,10 @@ module RightSupport::Net
   # MAY NOT BE SUFFICIENT for some uses of the request balancer! Please use the :fatal
   # option if you need different behavior.
   class RequestBalancer
+    DEFAULT_RETRY_PROC = lambda do |ep, n|
+      n < ep.size
+    end
+
     DEFAULT_FATAL_EXCEPTIONS = [ScriptError, ArgumentError, IndexError, LocalJumpError, NameError]
 
     DEFAULT_FATAL_PROC = lambda do |e|
@@ -35,11 +43,28 @@ module RightSupport::Net
       end
     end
 
+    DEFAULT_HEALTH_CHECK_PROC = Proc.new do |endpoint|
+      true
+    end
+
     DEFAULT_OPTIONS = {
+        :policy       => nil,
+        :retry        => DEFAULT_RETRY_PROC,
         :fatal        => DEFAULT_FATAL_PROC,
-        :on_exception => nil
+        :on_exception => nil,
+        :health_check => DEFAULT_HEALTH_CHECK_PROC
     }
 
+    @@logger = nil
+    
+    def self.logger
+      @@logger
+    end
+
+    def self.logger=(logger)
+      @@logger = logger
+    end
+
     def self.request(endpoints, options={}, &block)
       new(endpoints, options).request(&block)
     end
@@ -52,8 +77,10 @@ module RightSupport::Net
     # endpoints(Array):: a set of network endpoints (e.g. HTTP URLs) to be load-balanced
     #
     # === Options
-    # fatal(Class):: a class, list of classes or decision Proc to determine whether an exception is fatal and should not be retried
-    # on_exception(Proc|Lambda):: notification hook that accepts three arguments: whether the exception is fatal, the exception itself, and the endpoint for which the exception happened
+    # 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
+    # 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 is not healthy
     #
     def initialize(endpoints, options={})
       @options = DEFAULT_OPTIONS.merge(options)
@@ -62,7 +89,18 @@ module RightSupport::Net
         raise ArgumentError, "Must specify at least one endpoint"
       end
 
-      unless test_callable_arity(options[:fatal], 1, true)
+      @options[:policy] ||= RightSupport::Net::Balancing::RoundRobin
+      @policy = @options[:policy]
+      @policy = @policy.new(endpoints,options) if @policy.is_a?(Class)
+      unless test_policy_duck_type(@policy)
+        raise ArgumentError, ":policy must be a class/object that responds to :next, :good and :bad"
+      end
+
+      unless test_callable_arity(options[:retry], 2)
+        raise ArgumentError, ":retry callback must accept two parameters"
+      end
+
+      unless test_callable_arity(options[:fatal], 1)
         raise ArgumentError, ":fatal callback must accept one parameter"
       end
 
@@ -70,6 +108,10 @@ module RightSupport::Net
         raise ArgumentError, ":on_exception callback must accept three parameters"
       end
 
+      unless test_callable_arity(options[:health_check], 1, false)
+        raise ArgumentError, ":health_check callback must accept one parameters"
+      end
+
       @endpoints = endpoints.shuffle
     end
 
@@ -94,27 +136,59 @@ module RightSupport::Net
       complete   = false
       n          = 0
 
-      while !complete && n < @endpoints.size
-        endpoint = next_endpoint
+      retry_opt     = @options[:retry] || DEFAULT_RETRY_PROC
+      health_check  = @options[:health_check]
+
+      loop do
+        if complete
+          break
+        else
+          max_n = retry_opt
+          max_n = max_n.call(@endpoints, n) if max_n.respond_to?(:call)
+          break if (max_n.is_a?(Integer) && n >= max_n) || !(max_n)
+        end
+
+        endpoint, need_health_check  = @policy.next
+
+        raise NoResult, "No endpoints are available" unless endpoint
         n += 1
+        t0 = Time.now
+
+        # HealthCheck goes here
+        if need_health_check
+          begin
+            @policy.health_check(endpoint)
+          rescue Exception => e
+            @policy.bad(endpoint, t0, Time.now)
+            log_error("RequestBalancer: health check failed to #{endpoint} because of #{e.class.name}: #{e.message}")
+            next
+          end
+
+          log_info("RequestBalancer: health check succeeded to #{endpoint}")
+        end
 
         begin
           result   = yield(endpoint)
+          @policy.good(endpoint, t0, Time.now)
           complete = true
           break
         rescue Exception => e
+          @policy.bad(endpoint, t0, Time.now)
           if to_raise = handle_exception(endpoint, e)
             raise(to_raise)
           else
             exceptions << e
           end
         end
+
       end
 
       return result if complete
 
       exceptions = exceptions.map { |e| e.class.name }.uniq.join(', ')
-      raise NoResult, "All URLs in the rotation failed! Exceptions: #{exceptions}"
+      msg = "No available endpoints from #{@endpoints.inspect}! Exceptions: #{exceptions}"
+      log_error("RequestBalancer: #{msg}")
+      raise NoResult, msg
     end
 
     protected
@@ -135,7 +209,8 @@ module RightSupport::Net
       #whether the exception we're handling is an instance of any mentioned exception
       #class
       fatal = fatal.any?{ |c| e.is_a?(c) } if fatal.respond_to?(:any?)
-
+      msg = "RequestBalancer: rescued #{fatal ? 'fatal' : 'retryable'} #{e.class.name} during request to #{endpoint}: #{e.message}"
+      log_error msg
       @options[:on_exception].call(fatal, e, endpoint) if @options[:on_exception]
 
       if fatal
@@ -146,20 +221,28 @@ module RightSupport::Net
       end
     end
 
-    def next_endpoint
-      @round_robin ||= 0
-      result = @endpoints[ @round_robin % @endpoints.size ]
-      @round_robin += 1
-      return result
+    def test_policy_duck_type(object)
+      [:next, :good, :bad].all? { |m| object.respond_to?(m) }
     end
 
     # Test that something is a callable (Proc, Lambda or similar) with the expected arity.
     # Used mainly by the initializer to test for correct options.
-    def test_callable_arity(callable, arity, optional)
+    def test_callable_arity(callable, arity, optional=true)
       return true if callable.nil?
       return true if optional && !callable.respond_to?(:call)
       return callable.respond_to?(:arity) && (callable.arity == arity)
     end
+
+    # Log an info message with the class logger, if provided
+    def log_info(*args)
+      self.class.logger.__send__(:info, *args) if self.class.logger.respond_to?(:info)
+    end
+
+    # Log an error message with the class logger, if provided
+    def log_error(*args)
+      self.class.logger.__send__(:error, *args) if self.class.logger.respond_to?(:error)
+    end
+
   end # RequestBalancer
 
 end # RightScale

data/lib/right_support.rb

@@ -5,9 +5,3 @@ require 'right_support/log'
 require 'right_support/net'
 require 'right_support/rack'
 require 'right_support/validation'
-
-# Deprecated stubs
-require 'right_support/cassandra_model'
-require 'right_support/filter_logger'
-require 'right_support/system_logger'
-require 'right_support/tag_logger'

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 = '0.9.9'
-  s.date    = '2011-09-12'
+  s.version = '1.0.4'
+  s.date    = '2011-10-06'
 
   s.authors = ['Tony Spataro']
   s.email   = 'tony@rightscale.com'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: right_support
 version: !ruby/object:Gem::Version 
-  hash: 41
+  hash: 31
   prerelease: false
   segments: 
+  - 1
   - 0
-  - 9
-  - 9
-  version: 0.9.9
+  - 4
+  version: 1.0.4
 platform: ruby
 authors: 
 - Tony Spataro
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-12 00:00:00 -07:00
+date: 2011-10-06 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -136,26 +136,23 @@ files:
 - LICENSE
 - README.rdoc
 - lib/right_support.rb
-- lib/right_support/cassandra_model.rb
 - lib/right_support/db.rb
 - lib/right_support/db/cassandra_model.rb
-- lib/right_support/filter_logger.rb
 - lib/right_support/log.rb
 - lib/right_support/log/filter_logger.rb
 - lib/right_support/log/system_logger.rb
 - lib/right_support/log/tag_logger.rb
 - lib/right_support/net.rb
 - lib/right_support/net/address_helper.rb
+- lib/right_support/net/balancing.rb
+- lib/right_support/net/balancing/health_check.rb
+- lib/right_support/net/balancing/round_robin.rb
+- lib/right_support/net/http_client.rb
 - lib/right_support/net/request_balancer.rb
-- lib/right_support/net/request_balancer/policy.rb
-- lib/right_support/net/request_balancer/round_robin.rb
-- lib/right_support/net/rest.rb
 - lib/right_support/rack.rb
 - lib/right_support/rack/custom_logger.rb
 - lib/right_support/ruby.rb
 - lib/right_support/ruby/object_extensions.rb
-- lib/right_support/system_logger.rb
-- lib/right_support/tag_logger.rb
 - lib/right_support/validation.rb
 - lib/right_support/validation/openssl.rb
 - lib/right_support/validation/ssh.rb

data/lib/right_support/cassandra_model.rb

@@ -1,3 +0,0 @@
-module RightSupport
-  CassandraModel = RightSupport::DB::CassandraModel
-end

data/lib/right_support/filter_logger.rb

@@ -1,3 +0,0 @@
-module RightSupport
-  FilterLogger = RightSupport::Log::FilterLogger
-end

data/lib/right_support/net/request_balancer/policy.rb

@@ -1,14 +0,0 @@
-class RightSupport::Net::RequestBalancer::Policy
-  def next_endpoint
-    raise NotImplementedError, "Subclass responsibility"
-  end
-
-  def report_success(endpoint)
-    #no-op
-  end
-
-  def report_failure(endpoint)
-    #no-op
-  end
-end
-

data/lib/right_support/net/request_balancer/round_robin.rb

@@ -1,7 +0,0 @@
-class RightSupport::Net::RequestBalancer::RoundRobin < Policy
-  def next_endpoint(endpoints)
-    result = @endpoints[ @counter % @endpoints.size ]
-    @counter += 1
-    return result
-  end
-end

data/lib/right_support/net/rest.rb

@@ -1,90 +0,0 @@
-module RightSupport::Net
-  begin
-    require 'right_http_connection' 
-  rescue LoadError
-  end
-  if_require_succeeds('restclient') do
-    HAS_REST_CLIENT = true
-  end
-
-  # Raised to indicate that no suitable provider of REST/HTTP services was found. Since RightSupport's
-  # REST support is merely a wrapper around other libraries, it cannot work in isolation. See the REST
-  # module for more information about supported providers.
-  class NoProvider < Exception; end
-
-  #
-  # A wrapper for the rest-client gem that provides timeouts and other useful features while preserving
-  # the simplicity and ease of use of RestClient's simple, static (module-level) interface.
-  #
-  # Even though this code relies on RestClient, the right_support gem does not depend on the rest-client
-  # gem because not all users of right_support will want to make use of this interface. If one of REST's
-  # method is called and RestClient is not available, an exception will be raised.
-  #
-  #
-  # This module supports a subset of the module methods provided by RestClient and is interface-compatible
-  # with those methods it replaces; the only difference is that the REST version of each method accepts an
-  # additional, optional parameter which is a request timeout in seconds. The RestClient gem does not allow
-  # timeouts without instantiating a "heavyweight" REST client object.
-  #
-  #   # GET
-  #   xml = REST.get 'http://example.com/resource'
-  #   # and, with timeout of 5 seconds...
-  #   jpg = REST.get 'http://example.com/resource', :accept => 'image/jpg', 5
-  #
-  #   # authentication and SSL
-  #   REST.get 'https://user:password@example.com/private/resource'
-  #
-  #   # POST or PUT with a hash sends parameters as a urlencoded form body
-  #   REST.post 'http://example.com/resource', :param1 => 'one'
-  #
-  #   # nest hash parameters, add a timeout of 10 seconds (and specify "no extra headers")
-  #   REST.post 'http://example.com/resource', :nested => { :param1 => 'one' }, {}, 10
-  #
-  #   # POST and PUT with raw payloads
-  #   REST.post 'http://example.com/resource', 'the post body', :content_type => 'text/plain'
-  #   REST.post 'http://example.com/resource.xml', xml_doc
-  #   REST.put 'http://example.com/resource.pdf', File.read('my.pdf'), :content_type => 'application/pdf'
-  #
-  #   # DELETE
-  #   REST.delete 'http://example.com/resource'
-  #
-  #   # retrieve the response http code and headers
-  #   res = REST.get 'http://example.com/some.jpg'
-  #   res.code                    # => 200
-  #   res.headers[:content_type]  # => 'image/jpg'
-  module REST
-    DEFAULT_TIMEOUT = 5
-
-    # Wrapper around RestClient.get -- see class documentation for details.
-    def self.get(url, headers={}, timeout=DEFAULT_TIMEOUT, &block)
-      request(:method=>:get, :url=>url, :timeout=>timeout, :headers=>headers, &block)
-    end
-
-    # Wrapper around RestClient.get -- see class documentation for details.
-    def self.post(url, payload, headers={}, timeout=DEFAULT_TIMEOUT, &block)
-      request(:method=>:post, :url=>url, :payload=>payload,
-              :timeout=>timeout, :headers=>headers, &block)
-    end
-
-    # Wrapper around RestClient.get -- see class documentation for details.
-    def self.put(url, payload, headers={}, timeout=DEFAULT_TIMEOUT, &block)
-      request(:method=>:put, :url=>url, :payload=>payload,
-              :timeout=>timeout, :headers=>headers, &block)
-    end
-
-    # Wrapper around RestClient.get -- see class documentation for details.
-    def self.delete(url, headers={}, timeout=DEFAULT_TIMEOUT, &block)
-      request(:method=>:delete, :url=>url, :timeout=>timeout, :headers=>headers, &block)
-    end
-
-    # Wrapper around RestClient::Request.execute -- see class documentation for details.
-    def self.request(options, &block)
-      if HAS_REST_CLIENT
-        RestClient::Request.execute(options, &block)
-      else
-        raise NoProvider, "Cannot find a suitable HTTP client library"
-      end
-    end
-
-  end
-end

data/lib/right_support/system_logger.rb

@@ -1,3 +0,0 @@
-module RightSupport
-  SystemLogger = RightSupport::Log::SystemLogger if defined?(RightSupport::Log::SystemLogger)
-end

data/lib/right_support/tag_logger.rb

@@ -1,3 +0,0 @@
-module RightSupport
-  TagLogger = RightSupport::Log::TagLogger
-end