thrift-client 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 02cbfa3837919e23cc7f2d62998025440cde2ab7
+  data.tar.gz: 7fad55e8761f1a9154abe35b005aaad88085ad11
+SHA512:
+  metadata.gz: 433bc811fc642c33ffa21244d69e5ef2cf88aea4610efeb21f7b646d0743fbd4f040c1c2d961a1fe6d2345781a841ec036b2173246ac7a272a33e40f3bf6f0cc
+  data.tar.gz: cd261fa3ddeb856f19cddef85a2af7ff7f14d580326fdb6ba13769dc68037cf2de9cd544be15d4cf6d3d5db00907c32944909297db8e0b628b857e901c331bf2

data/lib/thrift_client.rb

@@ -0,0 +1,12 @@
+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/abstract_thrift_client'
+
+class ThriftClient < AbstractThriftClient
+  def initialize(options = {})
+    super
+  end
+end

data/lib/thrift_client/abstract_server.rb

@@ -0,0 +1,60 @@
+=begin
+  abstract thrift server information encapsulation
+  hold client connection
+=end
+class AbstractServer
+
+  attr_reader :host, :port, :client
+
+  def initialize(connect_string, options = {})
+    @host, @port = parse_connect_string(connect_string)
+    @options = options
+    @test_on_borrow = @options[:test_on_borrow]
+    @test_on_return = @options[:test_on_return]
+  end
+
+  def active?
+    raise NotImplementedError
+  end
+
+  def destroy
+    raise NotImplementedError
+  end
+
+  def disconnect(client)
+    client.close if client
+  end
+
+  def to_s
+    "#{host}:#{port}"
+  end
+
+  protected
+  def check_client(client)
+    begin
+      client.open unless client.open?
+      true
+    rescue Exception => e
+      false
+    end
+  end
+
+  def create_client
+    transport = @options[:transport].new(host, port, @options[:timeout])
+    transport = @options[:transport_wrapper].new(transport) if @options[:transport_wrapper]
+    protocol = @options[:protocol].new(transport)
+    if @options[:multiplexed]
+      protocol = Thrift::MultiplexedProtocol.new(protocol,@options[:client_class].name.split("::")[-2].downcase.gsub("service",""))
+    end
+    client = @options[:client_class].new(protocol)
+    client.open
+    return client
+  end
+
+  def parse_connect_string(connect_string)
+    host, port = connect_string.split(":")
+    raise ArgumentError, 'Server must be in the format "host:port"' unless host and port
+    [host, port]
+  end
+
+end

data/lib/thrift_client/abstract_thrift_client.rb

@@ -0,0 +1,261 @@
+require "thrift"
+=begin
+  abstract thrift client proxy, contains:
+  1.exception handle
+  2.method aspect
+  3.client create common logic encapsulation
+=end
+class NoAvailableServerError < RuntimeError; end
+class AbstractThriftClient
+  DISCONNECT_ERRORS = [
+    IOError,
+    Thrift::ProtocolException,
+    Thrift::TransportException
+  ]
+
+  APPLICATION_ERRORS =[
+    Thrift::ApplicationException
+  ]
+
+  # DEFAULT_BEFORE_METHOD = Proc.new {|method_name| puts "prepare call #{method_name} method."}
+  # DEFAULT_AFTER_METHOD = Proc.new {|method_name| puts "called #{method_name} method."}
+  # DEFAULT_ON_EXCEPTION = Proc.new {|method_name, e| puts "call #{method_name} method ouccur exception."; raise e}
+
+  DEFAULTS = {
+    :protocol => Thrift::CompactProtocol,
+    :transport => Thrift::Socket,
+    :transport_wrapper => Thrift::FramedTransport,
+    :disconnect_exception_classes => DISCONNECT_ERRORS,
+    :application_exception_classes => APPLICATION_ERRORS,
+    :size => 1,
+    :timeout => nil,
+    :client_class => nil,
+    :test_on_borrow => true,
+    :pool_timeout => 0,
+    :servers => "127.0.0.1:9090",
+    :multiplexed => false,
+    :before_method => nil,
+    :after_method => nil,
+    :on_exception => nil
+  }
+
+  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)
+    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|
+      if method_name != 'send_message' && method_name =~ /^send_(.*)$/
+        instance_eval("def #{$1}(*args); handle_method(:'#{$1}', *args); end", __FILE__, __LINE__)
+        @client_methods << $1
+      end
+    end
+  end
+
+  def add_callback(callback_type, &block)
+    case callback_type
+    when :before_method, :after_method, :on_exception
+      @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")
+    end
+    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
+      end
+    rescue *@options[:disconnect_exception_classes] => e
+      begin
+        server.disconnect(client) if server # tag the server is inactive
+      rescue Exception => e
+      end
+      #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
+      end
+    ensure
+      server.return_client(client) if server
+    end
+  end
+
+  def destroy
+    @server_list.each {|server| server.destroy if server}
+  end
+  
+  private
+  def next_server
+    @current_server_index ||= 0
+    @server_list.length.times do |i|
+      index = (1 + @current_server_index + i) % @server_list.length
+      @current_server_index = index
+      return @server_list[index]
+    end
+  end
+
+  def no_available_server
+    servers = @server_list.map { |s| s.to_s }.join(',')
+    raise NoAvailableServerError, "No available servers in [#{servers}]."
+  end
+
+  # 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 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)
+        user_options.store(:client_class, client_class)
+      else
+        raise ArgumentError, "client class [#{client_class}] is not a subclass of Thrift::Client"
+      end
+    else
+      raise ArgumentError, "client class is nil"
+    end
+
+    if options["protocol"] != nil
+      case options["protocol"]
+      when "compact"
+        protocol_class = Thrift::CompactProtocol
+      when "binary"
+        protocol_class = Thrift::BinaryProtocol
+      when "json"
+        protocol_class = Thrift::JsonProtocol
+      else
+        raise ArgumentError, "Unknown protocol type [#{options["protocol"]}], use compact|binary|json"
+      end
+      user_options.store(:protocol, protocol_class)
+    end
+
+    if options["transport"] != nil
+      case options["transport"]
+      when "socket"
+        transport_class = Thrift::Socket
+      when "unix_socket"
+        transport_class = Thrift::UNIXSockets
+      else
+        raise ArgumentError, "Unknown transport type [#{options["transport"]}], use socket|unix_socket"
+      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"
+      end
+      user_options.store(:transport_wrapper, transport_wrapper_class)
+    end
+
+    if options["disconnect_exception_classes"] != nil
+      user_define_disconnect_exceptions = options["disconnect_exception_classes"].split(",")
+      user_define_disconnect_exceptions.each do |exception|
+        exception_class = eval(exception)
+        if exception_class.ancestors.include?(Exception)
+          DISCONNECT_ERRORS.push(exception_class)
+        else
+          raise ArgumentError, "exception class [#{exception_class}] is not a subclass of Exception"
+        end
+      end
+      DISCONNECT_ERRORS.uniq!
+    end
+    user_options.store(:disconnect_exception_classes, DISCONNECT_ERRORS)
+
+    if options["application_exception_classes"] != nil
+      user_define_application_exceptions = options["application_exception_classes"].split(",")
+      user_define_application_exceptions.each do |exception|
+        exception_class = eval(exception)
+        if exception_class.ancestors.include?(Exception)
+          APPLICATION_ERRORS.push(exception_class)
+        else
+          raise ArgumentError, "exception class [#{exception_class}] is not a subclass of Exception"
+        end
+      end
+      APPLICATION_ERRORS.uniq!
+    end
+    user_options.store(:application_exception_classes, APPLICATION_ERRORS)
+
+    if options["size"] != nil
+      user_options.store(:size, options["size"].to_i)
+    end
+
+    if options["timeout"] != nil
+      user_options.store(:timeout, options["timeout"].to_i)
+    end
+
+    if options["multiplexed"] != nil
+      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')
+    end
+    # puts user_options[:test_on_borrow]
+    return user_options
+  end
+
+  def parse_servers(servers_string)
+    if servers_string != nil
+      return servers_string.split(",")
+    else
+      raise ArgumentError, "servers info is nil"
+    end
+  end
+
+end

data/lib/thrift_client/multi_client_server.rb

@@ -0,0 +1,59 @@
+require 'thread'
+require 'timeout'
+=begin
+  multi client connection thrift server encapsulation
+=end
+class MultiClientServer < AbstractServer
+
+  def initialize(connect_string, options = {})
+    super
+    @pool_timeout = @options[:pool_timeout]
+    @pool = Array.new(@options[:size]) { client = create_client }
+    @mutex = Mutex.new
+    @resource = ConditionVariable.new
+  end
+
+  def active?
+    active = false
+    @pool.each {|client| active = client.open?; break if active}
+    return active
+  end
+
+  def destroy
+    @pool.each {|client| client.close if client}
+  end
+
+  def get_client
+    client = pop
+    if @test_on_borrow
+      if check_client(client)
+        return client
+      else
+        return nil
+      end
+    else
+      client
+    end
+  end
+
+  def return_client(client)
+    client = create_client unless client.open?
+    @mutex.synchronize do
+      @pool.push client
+      @resource.broadcast
+    end
+  end
+
+  private 
+  def pop
+    deadline = Time.now + @pool_timeout
+    @mutex.synchronize do
+      loop do
+        return @pool.pop unless @pool.empty?
+        to_wait = deadline - Time.now
+        raise Timeout::Error, "Waited #{@pool_timeout} seconds" if to_wait <= 0 and @pool_timeout > 0
+        @resource.wait(@mutex, to_wait)
+      end
+    end
+  end
+end

data/lib/thrift_client/single_client_server.rb

@@ -0,0 +1,37 @@
+=begin
+  single client connection thrift server encapsulation
+=end
+class SingleClientServer < AbstractServer
+
+  def initialize(connect_string, options = {})
+    super
+    @client = create_client
+  end
+
+  def active?
+    @client.open?
+  end
+
+  def destroy
+    @client.close if @client
+    @client = nil
+  end
+
+  def get_client
+    @client = create_client unless @client
+    if @test_on_borrow
+      if check_client(@client)
+        return @client
+      else
+        return nil
+      end
+    else
+      @client
+    end
+  end
+
+  def return_client(client)
+    @client = nil unless @client.open?
+  end
+
+end

data/lib/thrift_client/thrift.rb

@@ -0,0 +1,239 @@
+module Thrift
+  module Client
+    def close
+      @iprot.trans.close
+    end
+
+    def open
+      @iprot.trans.open
+    end
+
+    def open?
+      @iprot.trans.open?
+    end
+  end
+
+  class MultiplexedProcessor
+    def initialize
+      @actual_processors = Hash.new
+    end
+ 
+    def register(service_name, processor)
+      processor.instance_variable_set(:@service_name, service_name)
+      @actual_processors[service_name] = processor
+    end
+ 
+    def process(iprot, oprot)
+      name, type, seqid  = iprot.read_message_begin
+      service_name, method = name.split(':')
+      actual_processor = @actual_processors[service_name]
+      if actual_processor.respond_to?("process_#{method}")
+        actual_processor.send("process_#{method}", seqid, iprot, oprot)
+        true
+      else
+        iprot.skip(Types::STRUCT)
+        iprot.read_message_end
+        x = ApplicationException.new(ApplicationException::UNKNOWN_METHOD, 'Unknown function ' + name)
+        oprot.write_message_begin(name, MessageTypes::EXCEPTION, seqid)
+        x.write(oprot)
+        oprot.write_message_end
+        oprot.trans.flush
+        false
+      end
+    end
+  end
+
+  module Processor
+    def write_result(result, oprot, name, seqid)
+      if @service
+        oprot.write_message_begin(@service + ':' + name, MessageTypes::REPLY, seqid)
+      else
+        oprot.write_message_begin(name, MessageTypes::REPLY, seqid)
+      end
+      result.write(oprot)
+      oprot.write_message_end
+      oprot.trans.flush
+    end
+  end
+
+  class MultiplexedProtocol < BaseProtocol
+
+    def initialize(protocol,service_name)
+      @protocol = protocol
+      @service_name = service_name
+    end
+
+    def trans
+      @protocol.trans
+    end
+
+    def write_message_begin(name, type, seqid)
+      case type
+      when ::Thrift::MessageTypes.CALL, ::Thrift::MessageTypes.ONEWAY
+        @protocol.write_message_begin(@service_name + ":" + name, type, seqid)
+      else
+        @protocol.write_message_begin(name, type, seqid)
+      end 
+    end
+
+    def write_message_end
+      @protocol.write_message_end
+    end
+
+    def write_struct_begin(name)
+      @protocol.write_struct_begin(name)
+    end
+
+    def write_struct_end
+      @protocol.write_struct_end
+    end
+
+    def write_field_begin(name, type, id)
+      @protocol.write_field_begin(name, type, id)
+    end
+
+    def write_field_end
+      @protocol.write_field_end
+    end
+
+    def write_field_stop
+      @protocol.write_field_stop
+    end
+
+    def write_map_begin(ktype, vtype, size)
+      @protocol.write_map_begin(ktype, vtype, size)
+    end
+
+    def write_map_end
+      @protocol.write_map_end
+    end
+
+    def write_list_begin(etype, size)
+      @protocol.write_list_begin(etype, size)
+    end
+
+    def write_list_end
+      @protocol.write_list_end
+    end
+
+    def write_set_begin(etype, size)
+      @protocol.write_set_begin(etype, size)
+    end
+
+    def write_set_end
+      @protocol.write_set_end
+    end
+
+    def write_bool(bool)
+      @protocol.write_bool(bool)
+    end
+
+    def write_byte(byte)
+      @protocol.write_byte(byte)
+    end
+
+    def write_i16(i16)
+      @protocol.write_i16(i16)
+    end
+
+    def write_i32(i32)
+      @protocol.write_i32(i32)
+    end
+
+    def write_i64(i64)
+      @protocol.write_i64(i64)
+    end
+
+    def write_double(dub)
+      @protocol.write_double(dub)
+    end
+
+    def write_string(str)
+      @protocol.write_string(str)
+    end
+
+    def write_binary(buf)
+      @protocol.write_binary(buf)
+    end
+
+    def read_message_begin
+      @protocol.read_message_begin
+    end
+
+    def read_message_end
+      @protocol.read_message_end
+    end
+
+    def read_struct_begin
+      @protocol.read_struct_begin
+    end
+
+    def read_struct_end
+      @protocol.read_struct_end
+    end
+
+    def read_field_begin
+      @protocol.read_field_begin
+    end
+
+    def read_field_end
+      @protocol.read_field_end
+    end
+
+    def read_map_begin
+      @protocol.read_map_begin
+    end
+
+    def read_map_end
+      @protocol.read_map_end
+    end
+
+    def read_list_begin
+      @protocol.read_list_begin
+    end
+
+    def read_list_end
+      @protocol.read_list_end
+    end
+
+    def read_set_begin
+      @protocol.read_set_begin
+    end
+
+    def read_set_end
+      @protocol.read_set_end
+    end
+
+    def read_bool
+      @protocol.read_bool
+    end
+
+    def read_byte
+      @protocol.read_byte
+    end
+
+    def read_i16
+      @protocol.read_i16
+    end
+
+    def read_i32
+      @protocol.read_i32
+    end
+
+    def read_i64
+      @protocol.read_i64
+    end
+
+    def read_double
+      @protocol.read_double
+    end
+
+    def read_string
+      @protocol.read_string
+    end
+
+    def read_binary
+      @protocol.read_binary
+    end
+  end
+end