load_balanced_rest_client 1.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTNiMDJjMWFjYzkwYWQ0ZmU1ZmQzOWQ3Y2Y5NGY1ZTBlNmYzZTgyNQ==
+  data.tar.gz: !binary |-
+    OTQxNzA3NWIyNDBjY2YyMzljNzY4MmMyYWQ2ZjgyZGRhNzljNTFlNQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NWYwN2E0YmMzMGEyYTU3MTZiMzc5YzYxMDY2N2QxNjUwZGE0MzI1ZTk0YWU2
+    ZjQ0ODc3NjM4NmU0NjBjODI0NzVmMzhjZGUxMTNhZDRlYzZiYTUzOTgxMTE5
+    NTA2MmNkYzJkYWVhMWJlN2M4Mjc1YWM0NzMxZGFjYTNlOTk4YjQ=
+  data.tar.gz: !binary |-
+    MjhmMzJiM2YyZWQ2ZmRmZjFhNGY5MzBiZTI2ZjIyNWQzYTQ3Y2QxYzU2OGVj
+    MmM3OTQ1MTM5MDVlYzllZjRhYmQ3YmQyNTcxNGE3YTBmNGIzZDRmN2MxYjgx
+    MmExN2ZjNzYxZDMwMzI3ZWU3OGIyMDU0OTBkZDA3M2M2MmUxZmM=

data/lib/algorithms.rb

@@ -0,0 +1,2 @@
+require_relative "algorithms/exponential_downtime"
+require_relative "algorithms/linear_downtime"

data/lib/algorithms/exponential_downtime.rb

@@ -0,0 +1,14 @@
+class LoadBalancedRestClient
+  module Algorithms
+    class ExponentialDowntime
+      def initialize(exp = 2, factor = 60)
+        @e = exp
+        @f = factor
+      end
+
+      def call(x)
+        (x ** @e) * @f
+      end
+    end
+  end
+end

data/lib/algorithms/linear_downtime.rb

@@ -0,0 +1,13 @@
+class LoadBalancedRestClient
+  module Algorithms
+    class LinearDowntime
+      def initialize(factor = 60)
+        @f = factor
+      end
+
+      def call(x)
+        x * @f
+      end
+    end
+  end
+end

data/lib/cluster.rb

@@ -0,0 +1,32 @@
+class LoadBalancedRestClient
+  class Cluster
+    class NoServers < StandardError; end
+    attr_accessor :servers
+
+    def initialize(servers, opts={})
+      server_klass = opts[:server_klass] || Server
+
+      if servers.first.class.to_s != "LoadBalancedRestClient::Server"
+        @servers = servers.map {|server| server_klass.new(server, opts)}
+      else
+        @servers = servers
+      end
+
+      if servers.empty?
+        raise NoServers.new("No servers in cluster") 
+      end
+    end
+
+    def balance!
+      @servers.push(@servers.delete(next_server))
+    end
+
+    def next_server
+      servers_to_try.first || @servers.first
+    end
+
+    def servers_to_try
+      @servers.select {|server| server.should_try? }
+    end
+  end
+end

data/lib/load_balanced_rest_client.rb

@@ -0,0 +1,18 @@
+require 'rest-client'
+require 'logger'
+require_relative 'version'
+require_relative 'server'
+require_relative 'cluster'
+require_relative 'algorithms'
+require_relative 'load_balancer'
+require_relative 'rest_client_proxy'
+
+class LoadBalancedRestClient
+  attr_accessor :cluster, :load_balancer
+  include RestClientProxy
+
+  def initialize(servers, opts={})
+    @cluster       = Cluster.new(servers, opts)
+    @load_balancer = LoadBalancer.new(@cluster, opts)
+  end
+end

data/lib/load_balancer.rb

@@ -0,0 +1,61 @@
+class LoadBalancedRestClient
+  class LoadBalancer
+    class MaxTriesReached < StandardError; end
+    attr_accessor :cluster
+
+    def initialize(cluster, options = {})
+      @cluster                = cluster
+      @human_readable_cluster = cluster.servers_to_try.join(", ")
+      @exceptions_to_catch    = options[:catch]     || [Errno::ECONNREFUSED, Errno::EHOSTUNREACH,
+                                                        RestClient::ServerBrokeConnection, RestClient::RequestTimeout]
+      @max_tries              = options[:max_tries] || 4
+      @logger                 = options[:logger]    || Logger.new(STDOUT)
+
+      @logger.info "Setting up load balancing: #{@human_readable_cluster}"
+    end
+
+    def with_server(&req_blk)
+      @try_counter = 0
+      result       = false
+
+      until result or @try_counter == @max_tries do
+        @try_counter += 1
+        @server       = @cluster.next_server
+
+        @cluster.balance!
+        @logger.info "#{human_readable_request_counter}: Trying #{@server}"
+        result = try_request(&req_blk)
+      end
+
+      if result
+        result
+      else
+        @logger.error "Max tries reached"
+        raise MaxTriesReached.new("Max tries reached")
+      end
+    end
+
+    private
+      def human_readable_request_counter
+        "Request #{@try_counter}/#{@max_tries}"
+      end
+
+      def try_request(&req_blk)
+        begin
+          result = yield @server
+          @logger.info "#{human_readable_request_counter}: #{@server} successful"
+          @server.stop_marking_down!
+
+          result
+        rescue *@exceptions_to_catch => e
+          @logger.info "#{human_readable_request_counter}: #{@server} threw \"#{e}\""
+          if @server.should_try?
+            @logger.warn "Marking server down: #{@server} for #{@server.next_downtime} seconds"
+            @server.mark_down!
+          end
+
+          nil
+        end
+      end
+  end
+end

data/lib/rest_client_proxy.rb

@@ -0,0 +1,24 @@
+class LoadBalancedRestClient
+  class RestClientProxyCall
+    def initialize(load_balancer, uri = nil)
+      @load_balancer = load_balancer
+      @uri           = uri
+    end
+
+    def method_missing(method_name, *args, &blk)
+      @load_balancer.with_server do |server|
+        server.client[@uri].send(method_name, *args, &blk)
+      end
+    end
+  end
+
+  module RestClientProxy
+    def [](uri)
+      RestClientProxyCall.new(@load_balancer, uri)
+    end
+
+    def method_missing(method_name, *args, &blk)
+      RestClientProxyCall.new(@load_balancer).send(method_name, *args, &blk)
+    end
+  end
+end

data/lib/server.rb

@@ -0,0 +1,61 @@
+class LoadBalancedRestClient
+  class Server
+    attr_accessor :client, :max_downtime, :downtime_counter
+
+    def initialize(url, opts={})
+      @url                 = url
+      @client              = opts[:client_klass]       || ::RestClient::Resource.new(url, opts)
+      @max_downtime        = opts[:max_downtime]       || 60 * 60 #= 1 hour
+      @downtime_algorithm  = opts[:downtime_algorithm] || ::LoadBalancedRestClient::Algorithms::ExponentialDowntime.new
+      @downtime_counter    = 0
+    end
+
+    def mark_down_for!(time_amount)
+      @downtime_counter += 1
+      @marked_down_until = Time.now + with_max_downtime { time_amount }
+
+      true
+    end
+
+    def mark_down!
+      if should_try?
+        downtime = next_downtime
+        mark_down_for! downtime
+
+        downtime
+      else
+        false
+      end
+    end
+
+    def stop_marking_down!
+      @marked_down_until = nil
+      @downtime_counter  = 0
+      true
+    end
+
+    def should_try?
+      !marked_down?
+    end
+
+    def marked_down?
+      !@marked_down_until.nil? && @marked_down_until > Time.now
+    end
+
+    def next_downtime
+      with_max_downtime do
+        @downtime_algorithm.call(@downtime_counter + 1)
+      end
+    end
+
+    def to_s
+      @url
+    end
+
+    private
+      def with_max_downtime(&block)
+        time_amount = yield
+        time_amount > @max_downtime ? @max_downtime : time_amount
+      end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+class LoadBalancedRestClient
+  VERSION = "1.0.2"
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: load_balanced_rest_client
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Eric Rafaloff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Automatically load balances a Rest Client, allowing you to enjoy the
+  benefits of redundancy without any additional points of failure.
+email: hello@eric.rafaloff.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/algorithms/exponential_downtime.rb
+- lib/algorithms/linear_downtime.rb
+- lib/algorithms.rb
+- lib/cluster.rb
+- lib/load_balanced_rest_client.rb
+- lib/load_balancer.rb
+- lib/rest_client_proxy.rb
+- lib/server.rb
+- lib/version.rb
+homepage: http://github.com/bitlove/load_balanced_rest_client
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib/
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: A client-side load balancer for RestClient
+test_files: []