fl-thrift_client 0.4.2 → 0.5.0

data/CHANGELOG

@@ -1,9 +1,43 @@
-v0.4.2 Allow per-method overrides of retries. Fix several bugs with EventMachine.
+v0.7.1 Added support for :before_method and :on_exception callback types.
+Added support for registering multiple callbacks of a given type.
 
-v0.4.1 Making ThriftClient decoratable. Able to add new functionality a class definition.
+v0.7.0 Updated thrift gem dependency to 0.7.0
+
+v0.6.3 Document the :connect_timeout option.
+Add support for specifying client-side timeouts when using FramedTransport
+set transport timeout after connection is established
+Add a method `add_callback` allowing a client to register a block that is invoked at a certain event.
+Fixup socket timeouts.
+
+
+
+v0.6.2 Remove lingering thrift v0.5.0 reference.
+
+v0.6.1 Add connect timeout. Bump thrift dependency to ~> v0.6.0.
+
+v0.6.0 Fix bug where we'd try to mark the current server down when we didn't have a current server.
+Upgrade to thrift 0.5.
+
+v0.5.0 Add support for wrapping exceptions, so that Thrift::Foo can become Greeter::Foo.
+Make server_retry_period work the way you expect.
+Better bookkeeping around marking servers as dead.
+
+v0.4.7 fix thrift gem dependency
+
+v0.4.6 Add support for oneway methods.
+
+v0.4.5. Fix broken retries.
+
+v0.4.4. Default to 0 retries rather than the number of servers.
+
+v0.4.3. Bug fixes: handle_exception could be called more than once. Integer types are read signed.
+
+v0.4.2. Allow per-method overrides of retries. Fix several bugs with EventMachine.
+
+v0.4.1. Making ThriftClient decoratable. Able to add new functionality a class definition.
 
 v0.4.0. Add new EventMachine transport.  This requires two layers of transport
-configurability: 
+configurability:
   options[:transport] for EventMachine or Socket transports
   options[:transport_wrapper] for optional Buffered or Framed Transport.
 Clients will need to update their options to ensure they don't conflict with this change. (mperham)

data/Manifest

@@ -21,3 +21,4 @@ test/simple_test.rb
 test/test_helper.rb
 test/thrift_client_http_test.rb
 test/thrift_client_test.rb
+thrift_client.gemspec

data/README.rdoc

@@ -30,6 +30,16 @@ You can then make calls to the server via the <tt>client</tt> instance as if was
 
 On failures, the client will try the remaining servers in the list before giving up. See ThriftClient for more.
 
+== Timeouts
+
+Timeouts are enforced per-try, so if you have a timeout of n and do m retries, the total time it could take is n*m.
+
+== Connection Handling
+
+The library will shuffle the host list then work its way down this list, only moving to the next host if it received an error or you've doing more than server_max_requests requests with that host (defaults to 0 which means there's no limit).
+
+Servers that throw an error get marked as dead and will only be retried every server_retry_period seconds (at that time all dead servers are retried, no matter long they've been marked as dead).
+
 == Installation
 
 You need Ruby 1.8 or 1.9. If you have those, just run:

data/Rakefile

@@ -3,14 +3,12 @@ require 'rubygems'
 require 'echoe'
 
 Echoe.new("thrift_client") do |p|
-  p.author = "Evan Weaver"
+  p.author = ["Evan Weaver", "Ryan King", "Jeff Hodges"]
   p.project = "fauna"
   p.summary = "A Thrift client wrapper that encapsulates some common failover behavior."
   p.rubygems_version = ">= 0.8"
-  p.dependencies = ['thrift']
+  p.dependencies = ['thrift ~>0.7.0']
   p.ignore_pattern = /^(vendor\/thrift)/
   p.rdoc_pattern = /^(lib|bin|tasks|ext)|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/
-  p.url = "http://blog.evanweaver.com/files/doc/fauna/thrift_client/"
-  p.docs_host = "blog.evanweaver.com:~/www/bax/public/files/doc/"
   p.spec_pattern = "spec/*_spec.rb"
 end

data/lib/thrift_client.rb

@@ -1,23 +1,10 @@
-if ENV["ANCIENT_THRIFT"]
-  $LOAD_PATH.unshift("/Users/eweaver/p/twitter/rails/vendor/gems/thrift-751142/lib")
-  $LOAD_PATH.unshift("/Users/eweaver/p/twitter/rails/vendor/gems/thrift-751142/ext")
-  require 'thrift'
-else
-  require 'rubygems'
-  require 'thrift'
-end
-
-require 'rubygems'
+require 'thrift'
 require 'thrift_client/thrift'
 require 'thrift_client/connection'
 require 'thrift_client/abstract_thrift_client'
 
 class ThriftClient < AbstractThriftClient
-  # This error is for backwards compatibility only. If defined in
-  # RetryingThriftClient instead, causes the test suite will break.
   class NoServersAvailable < StandardError; end
-  include RetryingThriftClient
-  include TimingOutThriftClient
 
 =begin rdoc
 Create a new ThriftClient instance. Accepts an internal Thrift client class (such as CassandraRb::Client), a list of servers with ports, and optional parameters.
@@ -26,17 +13,18 @@ Valid optional parameters are:
 
 <tt>:protocol</tt>:: Which Thrift protocol to use. Defaults to <tt>Thrift::BinaryProtocol</tt>.
 <tt>:protocol_extra_params</tt>:: An array of additional parameters to pass to the protocol initialization call. Defaults to <tt>[]</tt>.
-<tt>:transport</tt>:: Which Thrift transport to use. Defaults to <tt>Thrift::FramedTransport</tt>.
-<tt>:randomize_server_list</tt>:: Whether to connect to the servers randomly, instead of in order. Defaults to <tt>true</tt>.
-<tt>:exception_classes</tt>:: Which exceptions to catch and retry when sending a request. Defaults to <tt>[IOError, Thrift::Exception, Thrift::ProtocolException, Thrift::ApplicationException, Thrift::TransportException, NoServersAvailable]</tt>
+<tt>:transport</tt>:: Which Thrift transport to use. Defaults to <tt>Thrift::Socket</tt>.
+<tt>:transport_wrapper</tt>:: Which Thrift transport wrapper to use. Defaults to <tt>Thrift::FramedTransport</tt>.
+<tt>:exception_classes</tt>:: Which exceptions to catch and retry when sending a request. Defaults to <tt>[IOError, Thrift::Exception, Thrift::ApplicationException, Thrift::TransportException, NoServersAvailable]</tt>
+<tt>:exception_class_overrides</tt>:: For specifying children of classes in exception_classes for which you don't want to retry or reconnect.
 <tt>:raise</tt>:: Whether to reraise errors if no responsive servers are found. Defaults to <tt>true</tt>.
-<tt>:retries</tt>:: How many times to retry a request. Defaults to the number of servers defined.
-<tt>:server_retry_period</tt>:: How many seconds to wait before trying to reconnect after marking all servers as down. Defaults to <tt>1</tt>. Set to <tt>nil</tt> to retry endlessly.
+<tt>:retries</tt>:: How many times to retry a request. Defaults to 0.
+<tt>:server_retry_period</tt>:: How many seconds to wait before trying to reconnect to a dead server. Defaults to <tt>1</tt>. Set to <tt>nil</tt> to disable.
 <tt>:server_max_requests</tt>:: How many requests to perform before moving on to the next server in the pool, regardless of error status. Defaults to <tt>nil</tt> (no limit).
 <tt>:timeout</tt>:: Specify the default timeout in seconds. Defaults to <tt>1</tt>.
+<tt>:connect_timeout</tt>:: Specify the connection timeout in seconds. Defaults to <tt>0.1</tt>.
 <tt>:timeout_overrides</tt>:: Specify additional timeouts on a per-method basis, in seconds. Only works with <tt>Thrift::BufferedTransport</tt>.
 <tt>:defaults</tt>:: Specify default values to return on a per-method basis, if <tt>:raise</tt> is set to false.
-
 =end rdoc
 
   def initialize(client_class, servers, options = {})

data/lib/thrift_client/abstract_thrift_client.rb

@@ -1,29 +1,95 @@
 class AbstractThriftClient
 
+  class Server
+    attr_reader :connection_string, :marked_down_at
+
+    def initialize(connection_string)
+      @connection_string = connection_string
+    end
+    alias to_s connection_string
+
+    def mark_down!
+      @marked_down_at = Time.now
+    end
+  end
+
+  DISCONNECT_ERRORS = [
+    IOError,
+    Thrift::Exception,
+    Thrift::ApplicationException,
+    Thrift::TransportException
+  ]
+
+  DEFAULT_WRAPPED_ERRORS = [
+    Thrift::ApplicationException,
+    Thrift::TransportException,
+  ]
+
   DEFAULTS = {
     :protocol => Thrift::BinaryProtocol,
     :protocol_extra_params => [],
     :transport => Thrift::Socket,
     :transport_wrapper => Thrift::FramedTransport,
     :raise => true,
-    :defaults => {}
-  }.freeze
+    :defaults => {},
+    :exception_classes => DISCONNECT_ERRORS,
+    :exception_class_overrides => [],
+    :retries => 0,
+    :server_retry_period => 1,
+    :server_max_requests => nil,
+    :retry_overrides => {},
+    :wrapped_exception_classes => DEFAULT_WRAPPED_ERRORS,
+    :connect_timeout => 0.1,
+    :timeout => 1,
+    :timeout_overrides => {}
+  }
 
   attr_reader :client, :client_class, :current_server, :server_list, :options, :client_methods
 
   def initialize(client_class, servers, options = {})
     @options = DEFAULTS.merge(options)
+    @options[:server_retry_period] ||= 0
     @client_class = client_class
-    @server_list = Array(servers)
+    @server_list = Array(servers).collect{|s| Server.new(s)}.sort_by { rand }
     @current_server = @server_list.first
 
+    @callbacks = {}
     @client_methods = []
     @client_class.instance_methods.each do |method_name|
-      if method_name =~ /^recv_(.*)$/
+      if method_name != 'send_message' && method_name =~ /^send_(.*)$/
         instance_eval("def #{$1}(*args); handled_proxy(:'#{$1}', *args); end", __FILE__, __LINE__)
         @client_methods << $1
       end
     end
+    @request_count = 0
+    @options[:wrapped_exception_classes].each do |exception_klass|
+      name = exception_klass.to_s.split('::').last
+      begin
+        @client_class.const_get(name)
+      rescue NameError
+        @client_class.const_set(name, Class.new(exception_klass))
+      end
+    end
+  end
+
+  # Adds a callback that will be invoked at a certain time. The valid callback types are:
+  #   :post_connect  - should accept a single AbstractThriftClient argument, which is the client object to
+  #                    which the callback was added. Called after a connection to the remote thrift server
+  #                    is established.
+  #   :before_method - should accept a single method name argument. Called before a method is invoked on the
+  #                    thrift server.
+  #   :on_exception  - should accept 2 args: an Exception instance and a method name. Called right before the
+  #                    exception is raised.
+  def add_callback(callback_type, &block)
+    case callback_type
+    when :post_connect, :before_method, :on_exception
+      @callbacks[callback_type] ||= []
+      @callbacks[callback_type].push(block)
+      # Allow chaining
+      return self
+    else
+      return nil
+    end
   end
 
   def inspect
@@ -34,184 +100,106 @@ class AbstractThriftClient
   # called as the connection will be made on the first RPC method
   # call.
   def connect!
-    @connection = Connection::Factory.create(@options[:transport], @options[:transport_wrapper], @current_server, @options[:timeout])
+    @current_server = next_live_server
+    @connection = Connection::Factory.create(@options[:transport], @options[:transport_wrapper], @current_server.connection_string, @options[:connect_timeout])
     @connection.connect!
-    @client = @client_class.new(@options[:protocol].new(@connection.transport, *@options[:protocol_extra_params]))
-  rescue Thrift::TransportException, Errno::ECONNREFUSED => e
-    @transport.close rescue nil
-    raise e
+    transport = @connection.transport
+    transport.timeout = @options[:timeout] if transport_can_timeout?
+    @client = @client_class.new(@options[:protocol].new(transport, *@options[:protocol_extra_params]))
+    do_callbacks(:post_connect, self)
   end
 
   def disconnect!
-    @connection.close rescue nil
+    @connection.close rescue nil #TODO
     @client = nil
     @current_server = nil
+    @request_count = 0
   end
 
   private
-  def handled_proxy(method_name, *args)
-    proxy(method_name, *args)
-  rescue Exception => e
-    handle_exception(e, method_name, args)
-  end
-
-  def proxy(method_name, *args)
-    connect! unless @client
-    send_rpc(method_name, *args)
-  end
 
-  def send_rpc(method_name, *args)
-    @client.send(method_name, *args)
-  end
-
-  def disconnect_on_error!
-    @connection.close rescue nil
-    @client = nil
-    @current_server = nil
-  end
-
-  def handle_exception(e, method_name, args=nil)
-    raise e if @options[:raise]
-    @options[:defaults][method_name.to_sym]
-  end
-
-  module RetryingThriftClient
-    DISCONNECT_ERRORS = [
-                         IOError,
-                         Thrift::Exception,
-                         Thrift::ProtocolException,
-                         Thrift::ApplicationException,
-                         Thrift::TransportException
-                        ].freeze
-
-    RETRYING_DEFAULTS = {
-      :exception_classes => DISCONNECT_ERRORS,
-      :randomize_server_list => true,
-      :retries => nil,
-      :server_retry_period => 1,
-      :server_max_requests => nil,
-      :retry_overrides => {}
-    }.freeze
-
-    def initialize(client_class, servers, options = {})
-      super
-      @options = RETRYING_DEFAULTS.merge(@options) # @options is set by super
-      @retries = options[:retries] || @server_list.size
-      @request_count = 0
-      @max_requests = @options[:server_max_requests]
-      @retry_period = @options[:server_retry_period]
-      rebuild_live_server_list!
+  # Calls all callbacks of the specified type with the given args
+  def do_callbacks(callback_type_sym, *args)
+    return unless @callbacks[callback_type_sym]
+    @callbacks[callback_type_sym].each do |callback|
+      callback.call(*args)
     end
+  end
 
-    def connect!
-      @current_server = next_server
-      super
-    rescue Thrift::TransportException, Errno::ECONNREFUSED
-      retry
-    end
-
-    def disconnect!
-      # Keep live servers in the list if we have a retry period. Otherwise,
-      # always eject, because we will always re-add them.
-      if @retry_period && @current_server
-        @live_server_list.unshift(@current_server)
-      end
-
-      super()
-      @request_count = 0
-    end
-
-    private
-
-    def next_server
-      if @retry_period
-        rebuild_live_server_list! if Time.now > @last_rebuild + @retry_period
-        raise ThriftClient::NoServersAvailable, "No live servers in #{@server_list.inspect} since #{@last_rebuild.inspect}." if @live_server_list.empty?
-      elsif @live_server_list.empty?
-        rebuild_live_server_list!
+  def next_live_server
+    @server_index ||= 0
+    @server_list.length.times do |i|
+      cur = (1 + @server_index + i) % @server_list.length
+      if !@server_list[cur].marked_down_at || (@server_list[cur].marked_down_at + @options[:server_retry_period] <= Time.now)
+        @server_index = cur
+        return @server_list[cur]
       end
-      @live_server_list.pop
     end
+    raise ThriftClient::NoServersAvailable, "No live servers in #{@server_list.inspect} since #{@last_rebuild.inspect}."
+  end
 
-    def rebuild_live_server_list!
-      @last_rebuild = Time.now
-      if @options[:randomize_server_list]
-        @live_server_list = @server_list.sort_by { rand }
-      else
-        @live_server_list = @server_list.dup
+  def handled_proxy(method_name, *args)
+    disconnect_on_max! if @options[:server_max_requests] && @request_count >= @options[:server_max_requests]
+    begin
+      connect! unless @client
+      if has_timeouts?
+        @client.timeout = @options[:timeout_overrides][method_name.to_sym] || @options[:timeout]
       end
-    end
-
-    def handled_proxy(method_name, *args)
-      disconnect_on_max! if @max_requests and @request_count >= @max_requests
-      super
-    end
-
-    def proxy(method_name, *args)
-      super
+      @request_count += 1
+      do_callbacks(:before_method, method_name)
+      @client.send(method_name, *args)
+    rescue *@options[:exception_class_overrides] => e
+      raise_or_default(e, method_name)
     rescue *@options[:exception_classes] => e
       disconnect_on_error!
-      tries ||= (@options[:retry_overrides][method_name.to_sym] || @retries)
+      tries ||= (@options[:retry_overrides][method_name.to_sym] || @options[:retries]) + 1
       tries -= 1
-      tries == 0 ? handle_exception(e, method_name, args) : retry
-    end
-
-    def send_rpc(method_name, *args)
-      @request_count += 1
-      super
-    end
-
-    def disconnect_on_max!
-      @live_server_list.push(@current_server)
-      disconnect_on_error!
-    end
-
-    def disconnect_on_error!
-      super
-      @request_count = 0
+      if tries > 0
+        retry
+      else
+        raise_or_default(e, method_name)
+      end
+    rescue Exception => e
+      raise_or_default(e, method_name)
     end
-
   end
 
-  module TimingOutThriftClient
-    TIMINGOUT_DEFAULTS = {
-      :timeout => 1,
-      :timeout_overrides => {}
-    }.freeze
-
-    def initialize(client_class, servers, options = {})
-      super
-      @options = TIMINGOUT_DEFAULTS.merge(@options)
+  def raise_or_default(e, method_name)
+    if @options[:raise]
+      raise_wrapped_error(e, method_name)
+    else
+      @options[:defaults][method_name.to_sym]
     end
+  end
 
-    def connect!
-      super
-      set_method_timeouts!
+  def raise_wrapped_error(e, method_name)
+    do_callbacks(:on_exception, e, method_name)
+    if @options[:wrapped_exception_classes].include?(e.class)
+      raise @client_class.const_get(e.class.to_s.split('::').last), e.message, e.backtrace
+    else
+      raise e
     end
+  end
 
-    private
-    def set_method_timeouts!
-      return unless has_timeouts?
-      @client_methods.each do |method_name|
-        @client.timeout = @options[:timeout_overrides][method_name.to_sym] || @options[:timeout]
-      end
-    end
+  def disconnect_on_max!
+    disconnect!
+  end
 
-    def has_timeouts?
-      @has_timeouts ||= has_timeouts!
-    end
+  def disconnect_on_error!
+    @current_server.mark_down! if @current_server
+    disconnect!
+  end
 
-    def has_timeouts!
-      @options[:timeout_overrides].any? && transport_can_timeout?
-    end
+  def has_timeouts?
+    @has_timeouts ||= @options[:timeout_overrides].any? && transport_can_timeout?
+  end
 
-    def transport_can_timeout?
-      if (@options[:transport_wrapper] || @options[:transport]).method_defined?(:timeout=)
-        true
-      else
-        warn "ThriftClient: Timeout overrides have no effect with with transport type #{(@options[:transport_wrapper] || @options[:transport])}"
-        false
-      end
+  def transport_can_timeout?
+    if (@options[:transport_wrapper] || @options[:transport]).method_defined?(:timeout=)
+      true
+    else
+      warn "ThriftClient: Timeout overrides have no effect with with transport type #{(@options[:transport_wrapper] || @options[:transport])}"
+      false
     end
   end
 end

data/lib/thrift_client/connection.rb

@@ -1,5 +1,4 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + "/connection")
-require "base"
-require "socket"
-require "http"
-require "factory"
+require "thrift_client/connection/base"
+require "thrift_client/connection/socket"
+require "thrift_client/connection/http"
+require "thrift_client/connection/factory"

data/lib/thrift_client/event_machine.rb

@@ -26,6 +26,8 @@ module Thrift
         fiber.resume
       end
       Fiber.yield
+
+      raise Thrift::TransportException, "Unable to connect to #{@host}:#{@port}" unless @connection.connected?
       @connection
     end
 
@@ -65,32 +67,30 @@ module Thrift
     def initialize(host, port=9090)
       @host, @port = host, port
       @index = 0
-      @connected = false
+      @disconnected = 'not connected'
       @buf = ''
     end
 
     def close
       trap do
-        @connected = false
+        @disconnected = 'closed'
         close_connection(true)
       end
     end
 
     def blocking_read(size)
-      raise IOError, "lost connection to #{@host}:#{@port}" unless @connected
-      trap do
-        if can_read?(size)
-          yank(size)
-        else
-          raise ArgumentError, "Unexpected state" if @size or @callback
-
-          fiber = Fiber.current
-          @size = size
-          @callback = proc { |data|
-            fiber.resume(data)
-          }
-          Fiber.yield
-        end
+      raise IOError, "lost connection to #{@host}:#{@port}: #{@disconnected}" if @disconnected
+      if can_read?(size)
+        yank(size)
+      else
+        raise ArgumentError, "Unexpected state" if @size or @callback
+
+        fiber = Fiber.current
+        @size = size
+        @callback = proc { |data|
+          fiber.resume(data)
+        }
+        Fiber.yield
       end
     end
 
@@ -108,17 +108,17 @@ module Thrift
     end
 
     def connected?
-      @connected
+      !@disconnected
     end
 
     def connection_completed
-      @connected = true
+      @disconnected = nil
       succeed
     end
 
     def unbind
-      if @connected
-        @connected = false
+      if !@disconnected
+        @disconnected = 'unbound'
       else
         fail
       end

data/lib/thrift_client/simple.rb

@@ -100,7 +100,8 @@ class ThriftClient
           s.read(len)
         when I64
           hi, lo = s.read(8).unpack("NN")
-          (hi << 32) | lo
+          rv = (hi << 32) | lo
+          (rv >= (1 << 63)) ? (rv - (1 << 64)) : rv
         when LIST
           read_list(s)
         when MAP
@@ -114,7 +115,15 @@ class ThriftClient
         when StructType
           read_struct(s, type.struct_class)
         else
-          s.read(SIZES[type]).unpack(FORMATS[type]).first
+          rv = s.read(SIZES[type]).unpack(FORMATS[type]).first
+          case type
+          when I16
+            (rv >= (1 << 15)) ? (rv - (1 << 16)) : rv
+          when I32
+            (rv >= (1 << 31)) ? (rv - (1 << 32)) : rv
+          else
+            rv
+          end
         end
       end
 

data/lib/thrift_client/thrift.rb

@@ -1,4 +1,13 @@
 module Thrift
+  class BaseTransport
+    def timeout=(timeout)
+    end
+
+    def timeout
+      nil
+    end
+  end
+
   class BufferedTransport
     def timeout=(timeout)
       @transport.timeout = timeout
@@ -9,6 +18,16 @@ module Thrift
     end
   end
 
+  class FramedTransport
+    def timeout=(timeout)
+      @transport.timeout = timeout
+    end
+
+    def timeout
+      @transport.timeout
+    end
+  end
+  
   module Client
     def timeout=(timeout)
       @iprot.trans.timeout = timeout

data/test/greeter/greeter.rb

@@ -25,6 +25,13 @@ module Greeter
       raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'greeting failed: unknown result')
     end
 
+    def yo(name)
+      send_yo(name)
+    end
+
+    def send_yo(name)
+      send_message('yo', Yo_args, :name => name)
+    end
   end
 
   class Processor
@@ -37,15 +44,20 @@ module Greeter
       write_result(result, oprot, 'greeting', seqid)
     end
 
+    def process_yo(seqid, iprot, oprot)
+      args = read_args(iprot, Yo_args)
+      @handler.yo(args.name)
+      return
+    end
+
   end
 
   # HELPER FUNCTIONS AND STRUCTURES
 
   class Greeting_args
-    include ::Thrift::Struct
+    include ::Thrift::Struct, ::Thrift::Struct_Union
     NAME = 1
 
-    ::Thrift::Struct.field_accessor self, :name
     FIELDS = {
       NAME => {:type => ::Thrift::Types::STRING, :name => 'name'}
     }
@@ -55,13 +67,13 @@ module Greeter
     def validate
     end
 
+    ::Thrift::Struct.generate_accessors self
   end
 
   class Greeting_result
-    include ::Thrift::Struct
+    include ::Thrift::Struct, ::Thrift::Struct_Union
     SUCCESS = 0
 
-    ::Thrift::Struct.field_accessor self, :success
     FIELDS = {
       SUCCESS => {:type => ::Thrift::Types::STRING, :name => 'success'}
     }
@@ -71,6 +83,38 @@ module Greeter
     def validate
     end
 
+    ::Thrift::Struct.generate_accessors self
+  end
+
+  class Yo_args
+    include ::Thrift::Struct, ::Thrift::Struct_Union
+    NAME = 1
+
+    FIELDS = {
+      NAME => {:type => ::Thrift::Types::STRING, :name => 'name'}
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+    end
+
+    ::Thrift::Struct.generate_accessors self
+  end
+
+  class Yo_result
+    include ::Thrift::Struct, ::Thrift::Struct_Union
+
+    FIELDS = {
+
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+    end
+
+    ::Thrift::Struct.generate_accessors self
   end
 
 end

data/test/greeter/greeter.thrift

@@ -1,3 +1,4 @@
 service Greeter {
   string greeting(1:string name)
+  oneway void yo(1:string name)
 }

data/test/greeter/server.rb

@@ -3,6 +3,10 @@ module Greeter
     def greeting(name)
       "hello there #{name}!"
     end
+
+    def yo(name)
+      #whee
+    end
   end
 
   class Server

data/test/multiple_working_servers_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/test_helper"
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 
 class MultipleWorkingServersTest < Test::Unit::TestCase
   def setup

data/test/simple_test.rb

@@ -1,5 +1,4 @@
-
-require "#{File.dirname(__FILE__)}/test_helper"
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 
 class SimpleTest < Test::Unit::TestCase
 

data/test/test_helper.rb

@@ -1,4 +1,4 @@
-
+require 'rubygems'
 require 'test/unit'
 require 'benchmark'
 $LOAD_PATH << "#{File.expand_path(File.dirname(__FILE__))}/../lib"

data/test/thrift_client_http_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/test_helper"
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 require "thrift/server/mongrel_http_server"
 
 class ThriftClientHTTPTest < Test::Unit::TestCase
@@ -42,13 +42,5 @@ class ThriftClientHTTPTest < Test::Unit::TestCase
       ThriftClient.new(Greeter::Client, "http://127.0.0.1:1463/greeter", @options).greeting("someone")
     end
   end
-  
-  def test_non_random_fall_through
-    @servers = ["http://127.0.0.1:1463/greeter", "http://127.0.0.1:1461/greeter", "http://127.0.0.1:1462/greeter"]
-    assert_nothing_raised do
-      @options.merge!({ :protocol => Thrift::BinaryProtocol, :transport => Thrift::HTTPClientTransport })
-      ThriftClient.new(Greeter::Client, @servers, @options.merge(:randomize_server_list => false)).greeting("someone")
-    end
-  end
 
-end
+end

data/test/thrift_client_test.rb

@@ -1,10 +1,10 @@
-require "#{File.dirname(__FILE__)}/test_helper"
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 
 class ThriftClientTest < Test::Unit::TestCase
 
   def setup
     @servers = ["127.0.0.1:1461", "127.0.0.1:1462", "127.0.0.1:1463"]
-    @socket = 1461
+    @port = 1461
     @timeout = 0.2
     @options = {:protocol_extra_params => [false]}
     @pid = Process.fork do
@@ -32,15 +32,28 @@ class ThriftClientTest < Test::Unit::TestCase
     end
   end
 
-  def test_non_random_fall_through
+  def test_dont_raise
     assert_nothing_raised do
-      ThriftClient.new(Greeter::Client, @servers, @options.merge(:randomize_server_list => false)).greeting("someone")
+      ThriftClient.new(Greeter::Client, @servers.first, @options.merge(:raise => false)).greeting("someone")
     end
   end
 
-  def test_dont_raise
-    assert_nothing_raised do
-      ThriftClient.new(Greeter::Client, @servers.first, @options.merge(:raise => false)).greeting("someone")
+  def test_retries_correct_number_of_times
+    stub_server(@port) do |socket|
+      opts = @options.merge(:timeout => @timeout, :retries => 4, :server_retry_period => nil)
+      client = ThriftClient.new(Greeter::Client, "127.0.0.1:#{@port}", opts)
+      times_called = 0
+
+      singleton_class = (class << client; self end)
+
+      # disconnect_on_error! is called every time a server related
+      # connection error happens. it will be called every try (so, retries + 1)
+      singleton_class.send :define_method, :disconnect_on_error! do |*args|
+        times_called += 1; super *args
+      end
+
+      assert_raises(Greeter::Client::TransportException) { client.greeting("someone") }
+      assert_equal opts[:retries] + 1, times_called
     end
   end
 
@@ -57,7 +70,7 @@ class ThriftClientTest < Test::Unit::TestCase
   def test_random_fall_through
     assert_nothing_raised do
       10.times do
-        client = ThriftClient.new(Greeter::Client, @servers, @options)
+        client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:retries => 2))
         client.greeting("someone")
         client.disconnect!
       end
@@ -70,20 +83,109 @@ class ThriftClientTest < Test::Unit::TestCase
     end
   end
 
+  def test_post_conn_cb
+    calledcnt = 0
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:retries => 2))
+    r = client.add_callback :post_connect do |cl|
+      calledcnt += 1
+      assert_equal(client, cl)
+    end
+    assert_equal(client, r)
+    assert_nothing_raised do
+      client.greeting("someone")
+      client.disconnect!
+    end
+    assert_equal(1, calledcnt)
+  end
+
+  def test_before_method_cb
+    before_method_counts = Hash.new { |hash, key| hash[key] = 0 }
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:retries => 2))
+    r = client.add_callback :before_method do |method_name|
+      before_method_counts[method_name.to_sym] += 1
+    end
+    assert_equal(client, r)
+    assert_nothing_raised do
+      client.greeting("someone")
+      client.yo("dude")
+      client.yo("dawg")
+      client.disconnect!
+    end
+    assert_equal({:greeting => 1, :yo => 2}, before_method_counts)
+  end
+
+  def test_on_exception_cb
+    on_exception_counts = Hash.new { |h1, method_name| h1[method_name] = Hash.new { |h2, clazz| h2[clazz] = 0 }}
+    client = ThriftClient.new(Greeter::Client, @servers[0,2], @options.merge(:retries => 2))
+    r = client.add_callback :on_exception do |error, method_name|
+      on_exception_counts[method_name.to_sym][error.class] += 1
+    end
+    assert_equal(client, r)
+    assert_raises(ThriftClient::NoServersAvailable) do
+      client.greeting("someone")
+      client.disconnect!
+    end
+    assert_equal({:greeting => {ThriftClient::NoServersAvailable => 1}}, on_exception_counts)
+  end
+
+  def test_unknown_cb
+    calledcnt = 0
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:retries => 2))
+    r = client.add_callback :unknown do |cl|
+      assert(false)
+    end
+    assert_equal(nil, r)
+  end
+
+  def test_multiple_cb
+    calledcnt = 0
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:retries => 2))
+    2.times do |i|
+      r = client.add_callback :post_connect do |cl|
+        calledcnt += 1
+        assert_equal(client, cl)
+      end
+      assert_equal(client, r)
+    end
+    assert_nothing_raised do
+      client.greeting("someone")
+      client.disconnect!
+    end
+    assert_equal(2, calledcnt)
+  end
+
   def test_no_servers_eventually_raise
-    client = ThriftClient.new(Greeter::Client, @servers[0,2], @options)
+    wascalled = false
+    client = ThriftClient.new(Greeter::Client, @servers[0,2], @options.merge(:retries => 2))
+    client.add_callback :post_connect do
+      wascalled = true
+    end
     assert_raises(ThriftClient::NoServersAvailable) do
       client.greeting("someone")
       client.disconnect!
     end
+    assert(!wascalled)
+  end
+
+  def test_socket_timeout
+    stub_server(@port) do |socket|
+      measurement = Benchmark.measure do
+        assert_raises(Greeter::Client::TransportException) do
+          ThriftClient.new(Greeter::Client, "127.0.0.1:#{@port}",
+            @options.merge(:timeout => 1, :connect_timeout => 0.5)
+            ).greeting("someone")
+        end
+      end
+      assert(measurement.real > 0.5 && measurement.real < 1.05)
+    end
   end
 
   def test_framed_transport_timeout
-    stub_server(@socket) do |socket|
+    stub_server(@port) do |socket|
       measurement = Benchmark.measure do
-        assert_raises(Thrift::TransportException) do
-          ThriftClient.new(Greeter::Client, "127.0.0.1:#{@socket}",
-            @options.merge(:timeout => @timeout)
+        assert_raises(Greeter::Client::TransportException) do
+          ThriftClient.new(Greeter::Client, "127.0.0.1:#{@port}",
+            @options.merge(:timeout => @timeout, :connect_timeout => @timeout)
           ).greeting("someone")
         end
       end
@@ -92,12 +194,13 @@ class ThriftClientTest < Test::Unit::TestCase
   end
 
   def test_buffered_transport_timeout
-    stub_server(@socket) do |socket|
+    stub_server(@port) do |socket|
       measurement = Benchmark.measure do
-        assert_raises(Thrift::TransportException) do
-          ThriftClient.new(Greeter::Client, "127.0.0.1:#{@socket}",
-            @options.merge(:timeout => @timeout, :transport_wrapper => Thrift::BufferedTransport)
-          ).greeting("someone")
+        client = ThriftClient.new(Greeter::Client, "127.0.0.1:#{@port}",
+          @options.merge(:timeout => @timeout, :transport_wrapper => Thrift::BufferedTransport, :connect_timeout => @timeout)
+        )
+        assert_raises(Greeter::Client::TransportException) do
+          client.greeting("someone")
         end
       end
       assert((measurement.real > @timeout), "#{measurement.real} < #{@timeout}")
@@ -107,12 +210,13 @@ class ThriftClientTest < Test::Unit::TestCase
   def test_buffered_transport_timeout_override
     # FIXME Large timeout values always are applied twice for some bizarre reason
     log_timeout = @timeout * 4
-    stub_server(@socket) do |socket|
+    stub_server(@port) do |socket|
       measurement = Benchmark.measure do
-        assert_raises(Thrift::TransportException) do
-          ThriftClient.new(Greeter::Client, "127.0.0.1:#{@socket}",
-            @options.merge(:timeout => @timeout, :timeout_overrides => {:greeting => log_timeout}, :transport_wrapper => Thrift::BufferedTransport)
-          ).greeting("someone")
+        client = ThriftClient.new(Greeter::Client, "127.0.0.1:#{@port}",
+          @options.merge(:timeout => @timeout, :timeout_overrides => {:greeting => log_timeout}, :transport_wrapper => Thrift::BufferedTransport)
+        )
+        assert_raises(Greeter::Client::TransportException) do
+          client.greeting("someone")
         end
       end
       assert((measurement.real > log_timeout), "#{measurement.real} < #{log_timeout}")
@@ -120,21 +224,28 @@ class ThriftClientTest < Test::Unit::TestCase
   end
 
   def test_retry_period
-    client = ThriftClient.new(Greeter::Client, @servers[0,2], @options.merge(:server_retry_period => 1))
+    client = ThriftClient.new(Greeter::Client, @servers[0,2], @options.merge(:server_retry_period => 1, :retries => 2))
     assert_raises(ThriftClient::NoServersAvailable) { client.greeting("someone") }
     sleep 1.1
     assert_raises(ThriftClient::NoServersAvailable) { client.greeting("someone") }
   end
 
   def test_client_with_retry_period_drops_servers
-    client = ThriftClient.new(Greeter::Client, @servers[0,2], @options.merge(:server_retry_period => 1))
+    client = ThriftClient.new(Greeter::Client, @servers[0,2], @options.merge(:server_retry_period => 1, :retries => 2))
     assert_raises(ThriftClient::NoServersAvailable) { client.greeting("someone") }
     sleep 1.1
     assert_raises(ThriftClient::NoServersAvailable) { client.greeting("someone") }
   end
 
+  def test_oneway_method
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:server_max_requests => 2, :retries => 2))
+    assert_nothing_raised do
+      response = client.yo("dude")
+    end
+  end
+
   def test_server_max_requests_with_downed_servers
-    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:server_max_requests => 2))
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:server_max_requests => 2, :retries => 2))
     client.greeting("someone")
     internal_client = client.client
     client.greeting("someone")

data/thrift_client.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{fl-thrift_client}
-  s.version = "0.4.2"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0.8") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Weaver"]

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
-  - 4
-  - 2
-  version: 0.4.2
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Evan Weaver