thrift-client 0.1.0 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 866baefd0e4535af10cb51678e8612fde1bfba91
-  data.tar.gz: 2fbdff18a5e1b97b7fa0e628d2eb9c245b3df426
+  metadata.gz: 1480c3fe436b9ab1ac5fd52d5d97216695684994
+  data.tar.gz: 5821642a275b1d38d9d611eef88d0afb1cf4a30a
 SHA512:
-  metadata.gz: d3561f60edb1995911ead3c4f59179b972da8144c70cdb92bbab39e5fdb12a0bf0fc27b4387a15381470be98fe93df31fd10bc75224dba0567c64a70515b6819
-  data.tar.gz: 3141bf30248e2a6519b1f1484b18bfc223e1449af9897cff034502482d5b1cc70e76c9a2ba175d5b0171ff6854c3b1edae6fc00fa9c56defaab6a290d2041dbc
+  metadata.gz: e40434bf095d9fcafcda355cf2fc8ed49000b8877955e7e60e1e804c4a0be6e5be9bdc838e50c3a5c78df9cb858cb6e5da10a3d13be5fa3a615d51886baa6406
+  data.tar.gz: c3f9a470486255f5d1420a5deb4b5c7f2e48c1a54a23d3ccf0bdd5bc523c7ca782b2ac82985b047e19dad7e88f9bee7a4ff4c6392f95beb59b320602a3ea2cd0

data/lib/thrift_client.rb

@@ -1,12 +1,13 @@
 require 'thrift'
-require 'thrift_client/thrift'
-require 'thrift_client/abstract_server'
-require 'thrift_client/single_client_server'
-require 'thrift_client/multi_client_server'
+require 'thrift_client/thrift/client'
+require 'thrift_client/thrift/processor'
+require 'thrift_client/thrift/protocol'
+require 'thrift_client/thrift/struct'
+require 'thrift_client/thrift/transport'
 require 'thrift_client/abstract_thrift_client'
 
 class ThriftClient < AbstractThriftClient
   def initialize(options = {})
     super
   end
-end
+end

data/lib/thrift_client/abstract_thrift_client.rb

@@ -1,4 +1,6 @@
 require "thrift"
+require "thrift_client/server"
+
 =begin
   abstract thrift client proxy, contains:
   1.exception handle
@@ -6,6 +8,7 @@ require "thrift"
   3.client create common logic encapsulation
 =end
 class NoAvailableServerError < RuntimeError; end
+class ClientAlreadyDestroyedError < RuntimeError; end
 class AbstractThriftClient
   DISCONNECT_ERRORS = [
     IOError,
@@ -30,10 +33,9 @@ class AbstractThriftClient
     :size => 1,
     :timeout => nil,
     :client_class => nil,
-    :test_on_borrow => true,
-    :pool_timeout => 0,
     :servers => "127.0.0.1:9090",
     :multiplexed => false,
+    :retry => 0,
     :before_method => nil,
     :after_method => nil,
     :on_exception => nil
@@ -41,31 +43,19 @@ class AbstractThriftClient
 
   def initialize(options = {})
     user_options = initialize_options(options)
-    
+
     servers = parse_servers(options["servers"])
 
     #initialize options
     @options = DEFAULTS.merge(user_options)
 
-    if(@options[:size] > 1)
-      @options[:server_class] = MultiClientServer
-    else
-      @options[:server_class] = SingleClientServer
-    end
-
     #initialize servers info
     @server_list = servers.collect do |s|
-      @options[:server_class].new(s, @options)
+      Server.new(s, @options)
     end.sort_by { rand }
 
     @callbacks = {}
-    # @callbacks[:before_method] = []
-    # @callbacks[:after_method] = []
-    # @callbacks[:on_exception] = []
-    # @callbacks[:before_method].push(@options[:before_method])
-    # @callbacks[:after_method].push(@options[:after_method])
-    # @callbacks[:on_exception].push(DEFAULT_ON_EXCEPTION)
-    
+
     #initialize client methods
     @client_methods = []
     @options[:client_class].instance_methods.each do |method_name|
@@ -74,12 +64,14 @@ class AbstractThriftClient
         @client_methods << $1
       end
     end
+    @retry = @options[:retry]
+    @state = 1
   end
 
   def add_callback(callback_type, &block)
     case callback_type
     when :before_method, :after_method, :on_exception
-      @callbacks[callback_type] ||= []  
+      @callbacks[callback_type] ||= []
       @callbacks[callback_type].push(block)
     else
       raise ArgumentError.new("Unknown callback type #{callback_type},only support before_method|after_method|on_exception")
@@ -87,43 +79,84 @@ class AbstractThriftClient
     return self
   end
 
-  def handle_method(method_name, *args) 
-    begin
-      server = next_server
-      client = server.get_client
-      no_available_server unless client
-      do_callbacks(:before_method, method_name)
-      result = client.send(method_name, *args)
-      do_callbacks(:after_method, method_name)
-      return result
-    rescue *@options[:application_exception_classes] => e
-      #TODO whether or not wrapper these exceptions
-      if(@callbacks[:on_exception] && @callbacks[:on_exception].length > 0)
-        do_callbacks(:on_exception, method_name, e)
-      else
-        raise e
+  #retry two times
+  def handle_method(method_name, *args)
+    check_state
+    server = next_server
+    do_callbacks(:before_method, method_name)
+    result = server.with do |client|
+      tries = 0
+      begin
+        ensure_connected client
+        client.send(method_name, *args)
+      rescue *@options[:application_exception_classes] => e
+        if(@callbacks[:on_exception] && @callbacks[:on_exception].length > 0)
+          do_callbacks(:on_exception, method_name, e)
+        else
+          raise e
+        end
+      rescue *@options[:disconnect_exception_classes] => e
+        # if e instance_of? Thrift::TransportException && e.type == Thrift::TransportException::TIMED_OUT
+        begin
+          if client.connected?
+            client.disconnect
+          end
+        rescue Exception => e
+          puts "disconnect error"
+        end
+        if tries < @retry # retry two times
+          tries += 1
+          retry
+        end
+        if(@callbacks[:on_exception] && @callbacks[:on_exception].length > 0)
+          do_callbacks(:on_exception, method_name, e)
+        else
+          raise e
+        end
       end
-    rescue *@options[:disconnect_exception_classes] => e
+    end
+    do_callbacks(:after_method, method_name)
+    result
+  end
+
+  def destroy
+    @state = -1
+    @server_list.each { |server|
       begin
-        server.disconnect(client) if server # tag the server is inactive
+        server.destroy if server
       rescue Exception => e
+        puts "destroy server #{server} error, #{e.message}, #{e.backtrace}"
       end
-      #TODO whether or not wrapper these exceptions
-      if(@callbacks[:on_exception] && @callbacks[:on_exception].length > 0)
-        do_callbacks(:on_exception, method_name, e)
+    }
+  end
+
+  private
+
+  # 确保连接正常,在遇到异常时,重试一次
+  def ensure_connected(client)
+    try = true
+    begin
+      if !client.connected?
+        client.connect
+      end
+      client
+    rescue Exception => e
+      client.disconnect
+      if try
+        try = false
+        retry
       else
-        raise e
+        raise
       end
-    ensure
-      server.return_client(client) if server
     end
   end
 
-  def destroy
-    @server_list.each {|server| server.destroy if server}
+  def check_state
+    if @state < 0
+      raise ClientAlreadyDestroyedError, "Client had already destroyed."
+    end
   end
-  
-  private
+
   def next_server
     @current_server_index ||= 0
     @server_list.length.times do |i|
@@ -148,11 +181,18 @@ class AbstractThriftClient
 
   def initialize_options(options)
     user_options = {}
-    # puts options
-
     if options["client_class"] != nil
-      client_class = eval(options["client_class"])
-      if client_class.ancestors.include?(Thrift::Client)
+      client_class_str = options["client_class"].strip
+      if client_class_str.empty?
+        raise ArgumentError, "client class is empty string"
+      end
+      begin
+        client_class = eval(client_class_str)
+        flag = client_class.ancestors.include?(Thrift::Client)
+      rescue Exception => e
+        raise ArgumentError, "could not find class #{client_class_str}"
+      end
+      if flag
         user_options.store(:client_class, client_class)
       else
         raise ArgumentError, "client class [#{client_class}] is not a subclass of Thrift::Client"
@@ -180,23 +220,21 @@ class AbstractThriftClient
       when "socket"
         transport_class = Thrift::Socket
       when "unix_socket"
-        transport_class = Thrift::UNIXSockets
+        transport_class = Thrift::UNIXSocket
+      when "eventmachine"
+        transport_class = Thrift::EventMachineTransport
+      when "em"
+        transport_class = Thrift::EventMachineTransport
       else
-        raise ArgumentError, "Unknown transport type [#{options["transport"]}], use socket|unix_socket"
+        raise ArgumentError, "Unknown transport type [#{options["transport"]}], use socket|unix_socket|em(eventmachine)"
       end
       user_options.store(:transport, transport_class)
     end
 
-    if options["transport_wrapper"] != nil
-      case options["transport_wrapper"]
-      when "framed"
-        transport_wrapper_class = Thrift::FramedTransport
-      when "buffered"
-        transport_wrapper_class = Thrift::BufferedTransport
-      else
-        raise ArgumentError, "Unknown transport_wrapper type [#{options["transport_wrapper"]}], use framed|buffered"
+    if options["framed"] != nil
+      if options["framed"] != true
+        user_options.store(:transport_wrapper, Thrift::BufferedTransport)
       end
-      user_options.store(:transport_wrapper, transport_wrapper_class)
     end
 
     if options["disconnect_exception_classes"] != nil
@@ -239,23 +277,22 @@ class AbstractThriftClient
       user_options.store(:multiplexed, options["multiplexed"] || options["multiplexed"] == 'true')
     end
 
-    if options["pool_timeout"] != nil
-      user_options.store(:pool_timeout, options["pool_timeout"].to_i)
-    end
-
-    if options["test_on_borrow"] != nil
-      user_options.store(:test_on_borrow, options["test_on_borrow"] || options["test_on_borrow"] == 'true')
+    if options["retry"] != nil
+      user_options.store(:retry, options["retry"])
     end
-    # puts user_options[:test_on_borrow]
-    return user_options
+    user_options
   end
 
   def parse_servers(servers_string)
     if servers_string != nil
+      servers_string = servers_string.strip
+      if servers_string.empty?
+        raise ArgumentError, "servers info is empty string"
+      end
       return servers_string.split(",")
     else
       raise ArgumentError, "servers info is nil"
     end
   end
 
-end
+end

data/lib/thrift_client/pool.rb

@@ -0,0 +1,34 @@
+class ConnectionPool
+
+  def initialize(opts, &block)
+    @idle = []    #空闲的连接
+    @active = {}  #活动的连接
+    @pending = [] #等待的线程或纤程id
+    opts[:size].times do
+      @idle.push(block.call) if block_given?
+    end
+    @size = opts[:size]
+    @state = true # mark this pool active
+  end
+
+	def execute
+		raise NotImplementedError
+	end
+
+  # Returns current pool utilization.
+  #
+  # @return [Hash] Current utilization.
+  def status
+    {
+      state: state,
+      idle: @idle.size,
+      active: @active.size,
+      pending: @pending.size
+    }
+  end
+
+	def destroy
+		raise NotImplementedError
+	end
+
+end

data/lib/thrift_client/pool/fiber_connection_pool.rb

@@ -0,0 +1,67 @@
+require "thrift_client/pool"
+require "fiber"
+
+class FiberConnectionPool < ConnectionPool
+
+	def initialize(opts, &block)
+    super
+	end
+
+	# Choose first idle connection and pass it to the supplied
+	# block. This will block indefinitely until there is an idle
+	# connection to service the request.
+	def execute
+		f = Fiber.current
+		begin
+		  conn = acquire(f)
+		  yield conn
+		ensure
+		  release(f)
+		end
+	end
+
+  # Destroy all connections in this pool. It will waiting until
+  # all connections are idle and than close them one by one.
+	def destroy
+    while @idle.size < @size
+    	fiber = Fiber.current
+    	@pending.push fiber
+    	Fiber.yield
+    end
+    @idle.each do | conn |
+      begin
+        conn.disconnect
+      rescue Exception => e
+        puts "close connection error! #{e.backtrace}"
+      end
+    end
+	end
+
+	private
+
+	# Acquire a lock on a connection and assign it to executing fiber
+	# - if connection is idle, pass it back to the calling block
+	# - if pool is full, yield the current fiber until connection is idle
+	def acquire(fiber)
+	  if conn = @idle.pop
+	    @active[fiber.object_id] = conn
+	    conn
+	  else
+	  	@pending.push fiber
+	    Fiber.yield
+	    acquire(fiber)
+	  end
+	end
+
+	# Release connection assigned to the supplied fiber and
+	# resume any other pending connections (which will
+	# immediately try to run acquire on the pool)
+	def release(fiber)
+	  @idle.push(@active.delete(fiber.object_id))
+
+	  if pending = @pending.shift
+	    pending.resume
+	  end
+	end
+
+end

data/lib/thrift_client/pool/thread_connection_pool.rb

@@ -0,0 +1,69 @@
+require "thrift_client/pool"
+
+class ThreadConnectionPool < ConnectionPool
+
+  def initialize(opts, &block)
+    super
+    @mutex = Mutex.new
+    @condition = ConditionVariable.new
+  end
+
+	# Choose first idle connection and pass it to the supplied
+  # block. This will block indefinitely until there is an idle
+  # connection to service the request.
+  def execute
+    t = Thread.current
+    begin
+      conn = acquire(t)
+      yield conn
+    ensure
+      release(t)
+    end
+  end
+
+  # Destroy all connections in this pool. It will waiting until
+  # all connections are idle and than close them one by one.
+  def destroy
+    while @idle.size < @size
+      @mutex.synchronize do
+        @condition.wait(@mutex)
+      end
+    end
+    @idle.each do | conn |
+      begin
+        conn.disconnect
+      rescue Exception => e
+        puts "close connection error! #{e.backtrace}"
+      end
+    end
+  end
+
+  private
+
+  # Acquire a lock on a connection and assign it to executing thread
+  # - if connection is idle, pass it back to the calling block
+  # - if pool is full, stop the current thread until connection is idle
+  def acquire(thread)
+    @mutex.synchronize do
+      if conn = @idle.pop
+        @active[thread.object_id] = conn
+        return conn
+      else
+        @pending.push thread
+        @condition.wait(@mutex)
+        @pending.shift
+      end
+    end
+    acquire(thread)
+  end
+
+  # Release connection assigned to the supplied thread and
+  # wakeup any other pending connections (which will
+  # immediately try to run acquire on the pool)
+  def release(thread)
+    @mutex.synchronize do
+      @idle.push(@active.delete(thread.object_id))
+      @condition.broadcast
+    end
+  end
+end