thrift-client 0.1.0 → 0.3.4

data/lib/thrift_client/{abstract_server.rb → server.rb}

@@ -1,60 +1,62 @@
-=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
+class Server
+
+  def initialize(connect_string, options = {})
+    @active = false
+    @host, @port = parse_connect_string(connect_string)
+    @options = options
+    pool_class = nil
+    if @options[:transport] == Thrift::EventMachineTransport
+      require "thrift_client/pool/fiber_connection_pool"
+      pool_class = FiberConnectionPool
+    else
+      require "thrift_client/pool/thread_connection_pool"
+      pool_class = ThreadConnectionPool
+    end
+    @connection_pool = pool_class.new(:size => @options[:size]){
+      create_client
+    }
+    @active = true
+  end
+
+  def active?
+    @active
+  end
+
+  def destroy
+    @active = false
+    @connection_pool.destroy
+  end
+
+  def with
+    @connection_pool.execute { | connection |
+      if connection == nil
+        puts "fetal error, connection is nil"
+      end
+      yield connection
+    }
+  end
+
+  def to_s
+    "#{@host}:#{@port}"
+  end
+
+  protected
+  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.connect
+    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/thrift/client.rb

@@ -0,0 +1,15 @@
+module Thrift
+  module Client
+    def disconnect
+      @iprot.trans.close
+    end
+
+    def connect
+      @iprot.trans.open
+    end
+
+    def connected?
+      @iprot.trans.open?
+    end
+  end
+end

data/lib/thrift_client/thrift/processor.rb

@@ -0,0 +1,44 @@
+module Thrift
+  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 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
+end

data/lib/thrift_client/{thrift.rb → thrift/protocol.rb}

@@ -1,75 +1,4 @@
 module Thrift
-  module Client
-    def close
-      @iprot.trans.close
-    end
-
-    def open
-      @iprot.trans.open
-    end
-
-    def open?
-      @iprot.trans.open?
-    end
-  end
-
-  module Struct
-    def to_hash
-      hash = {}
-      each_field do |fid, field_info|
-        name = field_info[:name]
-        value = instance_variable_get("@#{name}")
-        unless field_info[:optional] && value.nil?
-          hash.store(name, value)
-        end
-      end
-      return hash
-    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)
@@ -87,7 +16,7 @@ module Thrift
         @protocol.write_message_begin(@service_name + ":" + name, type, seqid)
       else
         @protocol.write_message_begin(name, type, seqid)
-      end 
+      end
     end
 
     def write_message_end

data/lib/thrift_client/thrift/struct.rb

@@ -0,0 +1,15 @@
+module Thrift
+  module Struct
+    def to_hash
+      hash = {}
+      each_field do |fid, field_info|
+        name = field_info[:name]
+        value = instance_variable_get("@#{name}")
+        unless field_info[:optional] && value.nil?
+          hash.store(name, value)
+        end
+      end
+      return hash
+    end
+  end
+end

data/lib/thrift_client/thrift/transport.rb

@@ -0,0 +1,208 @@
+require 'eventmachine'
+require 'fiber'
+
+module Thrift
+  class TransportException
+    ALREADY_CLOSE = 5
+  end
+  class EventMachineTransport < BaseTransport
+    def initialize(host, port=9090, timeout=nil)
+      @host, @port, @timeout = host, port, timeout
+      @connection = nil
+    end
+
+    def open?
+      @connection && @connection.connected?
+    end
+
+    def open
+      @connection = EventMachine.connect(@host, @port, EventMachineConnection) do |conn|
+        conn.pending_connect_timeout = @timeout
+      end
+
+      fiber = Fiber.current
+
+      @connection.callback {  |arg|
+        if fiber == Fiber.current
+          return arg
+        else
+          fiber.resume(arg)
+        end
+      }
+      @connection.errback {  |arg|
+        if fiber == Fiber.current
+          return arg
+        else
+          fiber.resume(arg)
+        end
+      }
+
+      Fiber.yield
+
+      raise TransportException, TransportException::NOT_OPEN, "Unable to connect to #{@host}:#{@port}" unless @connection.connected?
+      @connection
+    end
+
+    def close
+      @connection.close if @connection && @connection.connected?
+    end
+
+    def read(sz)
+      raise IOError, "read failed, closed stream." unless open?
+      @connection.read(sz,@timeout)
+    end
+
+    def write(buf)
+      raise IOError, "write failed, closed stream." unless open?
+      @connection.write(buf,@timeout)
+    end
+  end
+
+  class EventMachineConnection < EventMachine::Connection
+    include EventMachine::Deferrable
+    BUFFER_SIZE = 4096 # 4kB
+
+    def post_init
+      @connected = false
+      @deferrable = nil
+      @rbuf = ''
+      @index = 0
+    end
+
+    def connected?
+      @connected
+    end
+
+    def connection_completed
+      @connected = true
+      succeed
+    end
+
+    def unbind
+      connected = @connected
+      @connected = false
+      deferrable = @deferrable
+      if connected
+        if deferrable
+          @deferrable = nil
+          deferrable.fail(:unbind)
+        else
+          puts "connection closed by server, but no deferrable was found."
+          fail
+        end
+      else
+        puts "connection closed"
+        fail
+      end
+    end
+
+    def on_read_timeout
+      trap do
+        deferrable = @deferrable
+        if deferrable
+          @deferrable = nil
+          deferrable.fail(:read)
+        else
+          puts "read timeout, but no deferrable was found."
+          fail
+        end
+      end
+    end
+
+    def close
+      trap do
+        if @connected
+          @connected = false
+          close_connection(true)
+        end
+      end
+    end
+
+    def write(buf,timeout)
+      callback {
+        send_data(buf)
+      }
+    end
+
+    def read(size,timeout)
+      timer = nil
+      if timeout and timeout > 0
+        timer = EventMachine.add_timer(timeout){
+          on_read_timeout
+        }
+      end
+      begin
+        data = nil
+        if can_read?(size)
+          data = yank(size)
+        else
+          @size = size
+          @deferrable ||= EventMachine::DefaultDeferrable.new
+          data = EventMachine::Synchrony.sync @deferrable
+          if data == :unbind
+            raise TransportException.new(TransportException::ALREADY_CLOSE, "connection already closed.")
+          elsif data == :read
+            raise TransportException.new(TransportException::TIMED_OUT, "read timeout")
+          elsif data == :readerror
+            raise TransportException.new(TransportException::UNKNOWN, "read unknown error")
+          end
+        end
+      ensure
+        if timer
+          EventMachine.cancel_timer(timer)
+        end
+      end
+      data
+    end
+
+    def receive_data(data)
+      trap do
+        puts data.length
+        @rbuf << data
+        if @deferrable and can_read?(@size)
+          data = yank(@size)
+          @size = nil
+          deferrable = @deferrable
+          @deferrable = nil
+          deferrable.succeed(data)
+        end
+      end
+    end
+
+    private
+
+    def can_read?(size)
+      @rbuf.size >= @index + size
+    end
+
+    def yank(len)
+      data = @rbuf.slice(@index, len)
+      @index += len
+      @index = @rbuf.size if @index > @rbuf.size
+      if @index >= BUFFER_SIZE
+        @rbuf = @rbuf.slice(@index..-1)
+        @index = 0
+      end
+      data
+    end
+
+    def trap
+      begin
+        yield
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace.join("\n")
+        # deferrable = @deferrable
+        # if deferrable
+        #   @deferrable = nil
+        #   deferrable.fail(:readerror)
+        # else
+        #   puts "read data error, but no deferrable was found."
+        #   fail
+        # end
+      end
+    end
+
+  end
+
+end