thrift_client-mavericks 0.8.4

data/test/greeter/server.rb

@@ -0,0 +1,44 @@
+module Greeter
+  class Handler
+    def greeting(name)
+      "hello there #{name}!"
+    end
+
+    def yo(name)
+      #whee
+    end
+  end
+
+  class Server
+    def initialize(port)
+      @port = port
+      handler = Greeter::Handler.new
+      processor = Greeter::Processor.new(handler)
+      transport = Thrift::ServerSocket.new("127.0.0.1", port)
+      transportFactory = Thrift::FramedTransportFactory.new()
+      @server = Thrift::SimpleServer.new(processor, transport, transportFactory)
+    end
+
+    def serve
+      @server.serve()
+    end
+  end
+
+  # client:
+  # trans = Thrift::HTTPClientTransport.new("http://127.0.0.1:9292/greeter")
+  # prot = Thrift::BinaryProtocol.new(trans)
+  # c = Greeter::Client.new(prot)
+  class HTTPServer
+    def initialize(uri)
+      uri = URI.parse(uri)
+      handler = Greeter::Handler.new
+      processor = Greeter::Processor.new(handler)
+      path = uri.path[1..-1]
+      @server = Thrift::MongrelHTTPServer.new(processor, :port => uri.port, :ip => uri.host, :path => path)
+    end
+
+    def serve
+      @server.serve()
+    end
+  end
+end

data/test/multiple_working_servers_test.rb

@@ -0,0 +1,112 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+
+class MultipleWorkingServersTest < Test::Unit::TestCase
+  def setup
+    @servers = ["127.0.0.1:1461", "127.0.0.1:1462", "127.0.0.1:1463"]
+    @socket = 1461
+    @timeout = 0.2
+    @options = {:protocol_extra_params => [false]}
+    @pids = []
+    @servers.each do |s|
+      @pids << Process.fork do
+        Signal.trap("INT") { exit }
+        Greeter::Server.new(s.split(':').last).serve
+      end
+    end
+    # Need to give the child process a moment to open the listening socket or
+    # we get occasional "could not connect" errors in tests.
+    sleep 0.05
+  end
+
+  def teardown
+    @pids.each do |pid|
+      Process.kill("INT", pid)
+      Process.wait(pid)
+    end
+  end
+
+  def test_server_creates_new_client_that_can_talk_to_all_servers_after_disconnect
+    client = ThriftClient.new(Greeter::Client, @servers, @options)
+    client.greeting("someone")
+    last_client = client.last_client
+    client.greeting("someone")
+    assert_equal last_client, client.last_client # Sanity check
+
+    client.disconnect!
+    client.greeting("someone")
+    last_client = client.last_client
+    client.greeting("someone")
+    assert_equal last_client, client.last_client
+    last_client = client.last_client
+    client.greeting("someone")
+    assert_equal last_client, client.last_client
+
+    # Moves on to the second server
+    assert_nothing_raised {
+      client.greeting("someone")
+      client.greeting("someone")
+    }
+  end
+
+  def test_server_doesnt_max_out_after_explicit_disconnect
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:server_max_requests => 2))
+    client.greeting("someone")
+    last_client = client.last_client
+    client.greeting("someone")
+    assert_equal last_client, client.last_client # Sanity check
+
+    client.disconnect!
+
+    client.greeting("someone")
+    last_client = client.last_client
+    client.greeting("someone")
+    assert_equal last_client, client.last_client, "ThriftClient should not have reset the internal client if the counter was reset on disconnect"
+  end
+
+  def test_server_disconnect_doesnt_drop_servers_with_retry_period
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:server_max_requests => 2, :retry_period => 1))
+    3.times {
+      client.greeting("someone")
+      last_client = client.last_client
+      client.greeting("someone")
+      assert_equal last_client, client.last_client # Sanity check
+
+      client.disconnect!
+
+      client.greeting("someone")
+      last_client = client.last_client
+      client.greeting("someone")
+      assert_equal last_client, client.last_client, "ThriftClient should not have reset the internal client if the counter was reset on disconnect"
+    }
+  end
+
+
+  def test_server_max_requests
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:server_max_requests => 2))
+
+    client.greeting("someone")
+    last_client = client.last_client
+
+    client.greeting("someone")
+    assert_equal last_client, client.last_client
+
+    # This next call maxes out the requests for that "client" object
+    # and moves on to the next.
+    client.greeting("someone")
+    assert_not_equal last_client, new_client = client.last_client
+
+    # And here we should still have the same client as the last one...
+    client.greeting("someone")
+    assert_equal new_client, client.last_client
+
+    # Until we max it out, too.
+    client.greeting("someone")
+    assert_not_equal new_client, client.last_client
+    assert_not_nil client.last_client
+
+    new_new_client = client.last_client
+    # And we should still have one server left
+    client.greeting("someone")
+    assert_equal new_new_client, client.last_client
+  end
+end

data/test/simple_test.rb

@@ -0,0 +1,136 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+
+class SimpleTest < Test::Unit::TestCase
+
+  S = ThriftClient::Simple
+  S.make_struct("Example", S::Field.new(:name, S::STRING, 1))
+  S.make_struct("Args")
+  S.make_struct("Retval", S::Field.new(:rv, S::I32, 0))
+
+  def test_definition
+    assert Struct::ST_Example
+    assert Struct::ST_Args
+    assert Struct::ST_Retval
+  end
+
+  ## Encoding
+
+  def test_boolean_encoding
+    assert_equal "\001", S.pack_value(S::BOOL, true)
+    assert_equal "\000", S.pack_value(S::BOOL, false)
+  end
+
+  def test_byte_encoding
+    assert_equal "\xc7", S.pack_value(S::BYTE, 199)
+  end
+
+  def test_i16_encoding
+    assert_equal "\x00\x96", S.pack_value(S::I16, 150)
+  end
+
+  def test_i32_encoding
+    assert_equal "\x00\x96\xb4\x3f", S.pack_value(S::I32, 9876543)
+  end
+
+  def test_i64_encoding
+    assert_equal "\x00\x00\x00\x1c\xbb\xf3\x09\x04", S.pack_value(S::I64, 123412351236)
+  end
+
+  def test_double_encoding
+    assert_equal "\x40\x23\x00\x00\x00\x00\x00\x00", S.pack_value(S::DOUBLE, 9.5)
+  end
+
+  def test_string_encoding
+    assert_equal "\x00\x00\x00\x05hello", S.pack_value(S::STRING, "hello")
+  end
+
+  def test_list_encoding
+    assert_equal "\x08\x00\x00\x00\x03\x00\x00\x00\x17\x00\x00\x00\x16\x00\x00\x00\x15", 
+      S.pack_value(S::ListType.new(S::I32), [ 23, 22, 21 ])
+  end
+
+  def test_map_encoding
+    assert_equal "\x0b\x08\x00\x00\x00\x01\x00\x00\x00\x03cat\x00\x00\x00\x05", 
+      S.pack_value(S::MapType.new(S::STRING, S::I32), "cat" => 5)
+  end
+
+  def test_set_encoding
+    assert_equal "\x08\x00\x00\x00\x01\x00\x00\x00\x04", 
+      S.pack_value(S::SetType.new(S::I32), [ 4 ])
+  end
+
+  def test_struct_encoding
+    assert_equal "\x0b\x00\x01\x00\x00\x00\x06Commie\x00", 
+      S.pack_value(S::StructType.new(Struct::ST_Example), Struct::ST_Example.new("Commie"))
+  end
+
+  def test_request_encoding
+    assert_equal "\x80\x01\x00\x01\x00\x00\x00\x09getHeight\x00\x00\x00\x17\x00", 
+      S.pack_request("getHeight", Struct::ST_Args.new, 23)
+  end
+
+  ## Decoding
+
+  def test_boolean_decoding
+    assert_equal true, S.read_value(StringIO.new("\x01"), S::BOOL)
+    assert_equal false, S.read_value(StringIO.new("\x00"), S::BOOL)
+  end
+
+  def test_byte_decoding
+    assert_equal -57, S.read_value(StringIO.new("\xc7"), S::BYTE)
+  end
+
+  def test_i16_decoding
+    assert_equal 150, S.read_value(StringIO.new("\x00\x96"), S::I16)
+  end
+
+  def test_i32_decoding
+    assert_equal 9876543, S.read_value(StringIO.new("\x00\x96\xb4\x3f"), S::I32)
+  end
+
+  def test_i64_decoding
+    assert_equal 123412351236, 
+      S.read_value(StringIO.new("\x00\x00\x00\x1c\xbb\xf3\x09\x04"), S::I64)
+  end
+
+  def test_double_decoding
+    assert_equal 9.5, 
+      S.read_value(StringIO.new("\x40\x23\x00\x00\x00\x00\x00\x00"), S::DOUBLE)
+  end
+
+  def test_string_decoding
+    assert_equal "hello", S.read_value(StringIO.new("\x00\x00\x00\x05hello"), S::STRING)
+  end
+
+  def test_list_decoding
+    assert_equal [ 23, 22, 21 ], 
+      S.read_value(StringIO.new("\x08\x00\x00\x00\x03\x00\x00\x00\x17\x00\x00\x00\x16\x00\x00\x00\x15"), 
+      S::ListType.new(S::I32))
+  end
+
+  def test_map_decoding
+    assert_equal({ "cat" => 5 }, 
+      S.read_value(StringIO.new("\x0b\x08\x00\x00\x00\x01\x00\x00\x00\x03cat\x00\x00\x00\x05"), 
+      S::MapType.new(S::STRING, S::I32)))
+  end
+
+  def test_set_decoding
+    assert_equal [ 4 ], 
+      S.read_value(StringIO.new("\x08\x00\x00\x00\x01\x00\x00\x00\x04"), 
+      S::ListType.new(S::I32))
+  end
+
+  def test_struct_decoding
+    assert_equal Struct::ST_Example.new("Commie"), 
+      S.read_value(StringIO.new("\x0b\x00\x01\x00\x00\x00\x06Commie\x00"), 
+      S::StructType.new(Struct::ST_Example))
+  end
+
+  def test_response_decoding
+    assert_equal [ "getHeight", 255, 1 ], 
+      S.read_response(
+      StringIO.new("\x80\x01\x00\x02\x00\x00\x00\x09getHeight\x00\x00\x00\xff\x08\x00\x00\x00\x00\x00\x01\x00"),
+      Struct::ST_Retval)
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'test/unit'
+require 'benchmark'
+$LOAD_PATH << "#{File.expand_path(File.dirname(__FILE__))}/../lib"
+require 'thrift_client'
+require 'thrift_client/simple'
+
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__)) 
+require 'greeter/greeter'
+require 'greeter/server'
+
+begin; require 'ruby-debug'; rescue LoadError; end

data/test/thrift_client_http_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+require "thrift/server/mongrel_http_server"
+
+class ThriftClientHTTPTest < Test::Unit::TestCase
+
+  def setup
+    @servers = ["http://127.0.0.1:1461/greeter", "http://127.0.0.1:1462/greeter", "http://127.0.0.1:1463/greeter"]
+    @socket = 1461
+    @timeout = 0.2
+    @options = {:protocol_extra_params => [false]}
+    @pid = Process.fork do
+      Signal.trap("INT") { exit }
+      Greeter::HTTPServer.new(@servers.last).serve
+    end
+    # Need to give the child process a moment to open the listening socket or
+    # we get occasional "could not connect" errors in tests.
+    sleep 0.05
+  end
+
+  def teardown
+    Process.kill("INT", @pid)
+    Process.wait
+  end
+
+  def test_bad_uri
+    assert_raises URI::InvalidURIError do
+      @options.merge!({ :protocol => Thrift::BinaryProtocol, :transport => Thrift::HTTPClientTransport })
+      ThriftClient.new(Greeter::Client, "127.0.0.1:1463", @options).greeting("someone")
+    end
+  end
+
+  def test_bad_uri_no_http
+    assert_raises ArgumentError do
+      @options.merge!({ :protocol => Thrift::BinaryProtocol, :transport => Thrift::HTTPClientTransport })
+      ThriftClient.new(Greeter::Client, "//127.0.0.1:1463", @options).greeting("someone")
+    end
+  end
+
+  def test_valid_server
+    assert_nothing_raised do
+      @options.merge!({ :protocol => Thrift::BinaryProtocol, :transport => Thrift::HTTPClientTransport })
+      ThriftClient.new(Greeter::Client, "http://127.0.0.1:1463/greeter", @options).greeting("someone")
+    end
+  end
+
+end

data/test/thrift_client_test.rb

@@ -0,0 +1,282 @@
+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"]
+    @port = 1461
+    @timeout = 0.2
+    @options = {:protocol_extra_params => [false]}
+    @pid = Process.fork do
+      Signal.trap("INT") { exit }
+      Greeter::Server.new("1463").serve
+    end
+    # Need to give the child process a moment to open the listening socket or
+    # we get occasional "could not connect" errors in tests.
+    sleep 0.05
+  end
+
+  def teardown
+    Process.kill("INT", @pid)
+    Process.wait
+  end
+
+  def test_inspect
+    client = ThriftClient.new(Greeter::Client, @servers.last, @options)
+    assert_equal "<ThriftClient(Greeter::Client) @current_server=127.0.0.1:1463>", client.inspect
+  end
+
+  def test_live_server
+    assert_nothing_raised do
+      ThriftClient.new(Greeter::Client, @servers.last, @options).greeting("someone")
+    end
+  end
+
+  def test_dont_raise
+    assert_nothing_raised do
+      ThriftClient.new(Greeter::Client, @servers.first, @options.merge(:raise => false)).greeting("someone")
+    end
+  end
+
+  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! do |*args|
+        times_called += 1 if args[0]; super *args
+      end
+
+      assert_raises(Greeter::Client::TransportException) { client.greeting("someone") }
+      assert_equal opts[:retries] + 1, times_called
+    end
+  end
+
+  def test_dont_raise_with_defaults
+    client = ThriftClient.new(Greeter::Client, @servers.first, @options.merge(:raise => false, :defaults => {:greeting => 1}))
+    assert_equal 1, client.greeting
+  end
+
+  def test_defaults_dont_override_no_method_error
+    client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:raise => false, :defaults => {:Missing => 2}))
+    assert_raises(NoMethodError) { client.Missing }
+  end
+
+  def test_random_fall_through
+    assert_nothing_raised do
+      10.times do
+        client = ThriftClient.new(Greeter::Client, @servers, @options.merge(:retries => 2))
+        client.greeting("someone")
+        client.disconnect!
+      end
+    end
+  end
+
+  def test_lazy_connection
+    assert_nothing_raised do
+      ThriftClient.new(Greeter::Client, @servers[0,2])
+    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
+    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(@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 => @timeout, :connect_timeout => @timeout)
+          ).greeting("someone")
+        end
+      end
+      assert((measurement.real > @timeout), "#{measurement.real} < #{@timeout}")
+    end
+  end
+
+  def test_buffered_transport_timeout
+    stub_server(@port) do |socket|
+      measurement = Benchmark.measure do
+        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}")
+    end
+  end
+
+  def test_buffered_transport_timeout_override
+    # FIXME Large timeout values always are applied twice for some bizarre reason
+    log_timeout = @timeout * 4
+    stub_server(@port) do |socket|
+      measurement = Benchmark.measure do
+        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}")
+    end
+  end
+
+  def test_retry_period
+    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_connect_retry_period
+    client = ThriftClient.new(Greeter::Client, @servers[0], @options.merge(:server_retry_period => 0))
+    assert_raises(ThriftClient::NoServersAvailable) { client.connect! }
+  end
+
+  def test_client_with_retry_period_drops_servers
+    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, :retries => 2))
+    client.greeting("someone")
+    last_client = client.last_client
+    client.greeting("someone")
+    assert_equal last_client, client.last_client
+
+    # This next call maxes out the requests for that "client" object
+    # and moves on to the next.
+    client.greeting("someone")
+    assert_not_equal last_client, new_client = client.last_client
+
+    # And here we should still have the same client as the last one...
+    client.greeting("someone")
+    assert_equal new_client, client.last_client
+
+    # Until we max it out, too.
+    client.greeting("someone")
+    assert_not_equal last_client, client.last_client
+  end
+
+  private
+
+  def stub_server(port)
+    socket = TCPServer.new('127.0.0.1', port)
+    Thread.new { socket.accept }
+    yield socket
+  ensure
+    socket.close
+  end
+end