thrift 0.0.751142

data/lib/thrift/protocol/tbinaryprotocol.rb

@@ -0,0 +1,2 @@
+require 'thrift/deprecation'
+require 'thrift/protocol/binaryprotocol'

data/lib/thrift/protocol/tprotocol.rb

@@ -0,0 +1,2 @@
+require 'thrift/deprecation'
+require 'thrift/protocol'

data/lib/thrift/protocol.rb

@@ -0,0 +1,270 @@
+#
+# Copyright (c) 2006- Facebook
+# Distributed under the Apache Software License
+#
+# See accompanying file LICENSE or visit the Thrift site at:
+# http://developers.facebook.com/thrift/
+#
+# Author: Mark Slee <mcslee@facebook.com>
+#
+
+# this require is to make generated struct definitions happy
+require 'set'
+
+module Thrift
+  class ProtocolException < Exception
+
+    UNKNOWN = 0
+    INVALID_DATA = 1
+    NEGATIVE_SIZE = 2
+    SIZE_LIMIT = 3
+    BAD_VERSION = 4
+
+    attr_reader :type
+
+    def initialize(type=UNKNOWN, message=nil)
+      super(message)
+      @type = type
+    end
+
+  end
+  deprecate_class! :TProtocolException => ProtocolException
+
+  class Protocol
+
+    attr_reader :trans
+
+    def initialize(trans)
+      @trans = trans
+    end
+
+    def native?
+      puts "wrong method is being called!"
+      false
+    end
+
+    def write_message_begin(name, type, seqid); nil; end
+    deprecate! :writeMessageBegin => :write_message_begin
+
+    def write_message_end; nil; end
+    deprecate! :writeMessageEnd => :write_message_end
+
+    def write_struct_begin(name); nil; end
+    deprecate! :writeStructBegin => :write_struct_begin
+
+    def write_struct_end; nil; end
+    deprecate! :writeStructEnd => :write_struct_end
+
+    def write_field_begin(name, type, id); nil; end
+    deprecate! :writeFieldBegin => :write_field_begin
+
+    def write_field_end; nil; end
+    deprecate! :writeFieldEnd => :write_field_end
+
+    def write_field_stop; nil; end
+    deprecate! :writeFieldStop => :write_field_stop
+
+    def write_map_begin(ktype, vtype, size); nil; end
+    deprecate! :writeMapBegin => :write_map_begin
+
+    def write_map_end; nil; end
+    deprecate! :writeMapEnd => :write_map_end
+
+    def write_list_begin(etype, size); nil; end
+    deprecate! :writeListBegin => :write_list_begin
+
+    def write_list_end; nil; end
+    deprecate! :writeListEnd => :write_list_end
+
+    def write_set_begin(etype, size); nil; end
+    deprecate! :writeSetBegin => :write_set_begin
+
+    def write_set_end; nil; end
+    deprecate! :writeSetEnd => :write_set_end
+
+    def write_bool(bool); nil; end
+    deprecate! :writeBool => :write_bool
+
+    def write_byte(byte); nil; end
+    deprecate! :writeByte => :write_byte
+
+    def write_i16(i16); nil; end
+    deprecate! :writeI16 => :write_i16
+
+    def write_i32(i32); nil; end
+    deprecate! :writeI32 => :write_i32
+
+    def write_i64(i64); nil; end
+    deprecate! :writeI64 => :write_i64
+
+    def write_double(dub); nil; end
+    deprecate! :writeDouble => :write_double
+
+    def write_string(str); nil; end
+    deprecate! :writeString => :write_string
+
+    def read_message_begin; nil; end
+    deprecate! :readMessageBegin => :read_message_begin
+
+    def read_message_end; nil; end
+    deprecate! :readMessageEnd => :read_message_end
+
+    def read_struct_begin; nil; end
+    deprecate! :readStructBegin => :read_struct_begin
+
+    def read_struct_end; nil; end
+    deprecate! :readStructEnd => :read_struct_end
+
+    def read_field_begin; nil; end
+    deprecate! :readFieldBegin => :read_field_begin
+
+    def read_field_end; nil; end
+    deprecate! :readFieldEnd => :read_field_end
+
+    def read_map_begin; nil; end
+    deprecate! :readMapBegin => :read_map_begin
+
+    def read_map_end; nil; end
+    deprecate! :readMapEnd => :read_map_end
+
+    def read_list_begin; nil; end
+    deprecate! :readListBegin => :read_list_begin
+
+    def read_list_end; nil; end
+    deprecate! :readListEnd => :read_list_end
+
+    def read_set_begin; nil; end
+    deprecate! :readSetBegin => :read_set_begin
+
+    def read_set_end; nil; end
+    deprecate! :readSetEnd => :read_set_end
+
+    def read_bool; nil; end
+    deprecate! :readBool => :read_bool
+
+    def read_byte; nil; end
+    deprecate! :readByte => :read_byte
+
+    def read_i16; nil; end
+    deprecate! :readI16 => :read_i16
+
+    def read_i32; nil; end
+    deprecate! :readI32 => :read_i32
+
+    def read_i64; nil; end
+    deprecate! :readI64 => :read_i64
+
+    def read_double; nil; end
+    deprecate! :readDouble => :read_double
+
+    def read_string; nil; end
+    deprecate! :readString => :read_string
+
+    def write_field(name, type, fid, value)
+      write_field_begin(name, type, fid)
+      write_type(type, value)
+      write_field_end
+    end
+
+    def write_type(type, value)
+      case type
+      when Types::BOOL
+        write_bool(value)
+      when Types::BYTE
+        write_byte(value)
+      when Types::DOUBLE
+        write_double(value)
+      when Types::I16
+        write_i16(value)
+      when Types::I32
+        write_i32(value)
+      when Types::I64
+        write_i64(value)
+      when Types::STRING
+        write_string(value)
+      when Types::STRUCT
+        value.write(self)
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def read_type(type)
+      case type
+      when Types::BOOL
+        read_bool
+      when Types::BYTE
+        read_byte
+      when Types::DOUBLE
+        read_double
+      when Types::I16
+        read_i16
+      when Types::I32
+        read_i32
+      when Types::I64
+        read_i64
+      when Types::STRING
+        read_string
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def skip(type)
+      case type
+      when Types::STOP
+        nil
+      when Types::BOOL
+        read_bool
+      when Types::BYTE
+        read_byte
+      when Types::I16
+        read_i16
+      when Types::I32
+        read_i32
+      when Types::I64
+        read_i64
+      when Types::DOUBLE
+        read_double
+      when Types::STRING
+        read_string
+      when Types::STRUCT
+        read_struct_begin
+        while true
+          name, type, id = read_field_begin
+          break if type == Types::STOP
+          skip(type)
+          read_field_end
+        end
+        read_struct_end
+      when Types::MAP
+        ktype, vtype, size = read_map_begin
+        size.times do
+          skip(ktype)
+          skip(vtype)
+        end
+        read_map_end
+      when Types::SET
+        etype, size = read_set_begin
+        size.times do
+          skip(etype)
+        end
+        read_set_end
+      when Types::LIST
+        etype, size = read_list_begin
+        size.times do
+          skip(etype)
+        end
+        read_list_end
+      end
+    end
+
+  end
+  deprecate_class! :TProtocol => Protocol
+
+  class ProtocolFactory
+    def get_protocol(trans); nil; end
+    deprecate! :getProtocol => :get_protocol
+  end
+  deprecate_class! :TProtocolFactory => ProtocolFactory
+end

data/lib/thrift/serializer.rb

@@ -0,0 +1,27 @@
+module Thrift
+  class Serializer
+    def initialize(protocolFactory = BinaryProtocolFactory.new)
+      @transport = MemoryBuffer.new
+      @protocol = protocolFactory.get_protocol(@transport)
+    end
+
+    def serialize(base)
+      @transport.reset_buffer
+      base.write(@protocol)
+      @transport.read(@transport.available)
+    end
+  end
+
+  class Deserializer
+    def initialize(protocolFactory = BinaryProtocolFactory.new)
+      @transport = MemoryBuffer.new
+      @protocol = protocolFactory.get_protocol(@transport)
+    end
+
+    def deserialize(base, buffer)
+      @transport.reset_buffer(buffer)
+      base.read(@protocol)
+      base
+    end
+  end
+end

data/lib/thrift/server/httpserver.rb

@@ -0,0 +1,44 @@
+require 'thrift/protocol'
+require 'thrift/protocol/binaryprotocol'
+require 'thrift/transport'
+
+require 'mongrel'
+
+## Sticks a service on a URL, using mongrel to do the HTTP work
+module Thrift
+  class SimpleMongrelHTTPServer
+    class Handler < Mongrel::HttpHandler
+      def initialize(processor, protocol_factory)
+        @processor = processor
+        @protocol_factory = protocol_factory
+      end
+
+      def process(request, response)
+        if request.params["REQUEST_METHOD"] == "POST"
+          response.start(200) do |head, out|
+            head["Content-Type"] = "application/x-thrift"
+            transport = IOStreamTransport.new request.body, out
+            protocol = @protocol_factory.get_protocol transport
+            @processor.process protocol, protocol
+          end
+        else
+          response.start(404) { }
+        end
+      end
+    end
+
+    def initialize(processor, opts={})
+      port = opts[:port] || 80
+      ip = opts[:ip] || "0.0.0.0"
+      path = opts[:path] || ""
+      protocol_factory = opts[:protocol_factory] || BinaryProtocolFactory.new
+      @server = Mongrel::HttpServer.new ip, port
+      @server.register "/#{path}", Handler.new(processor, protocol_factory)
+    end
+
+    def serve
+      @server.run.join
+    end
+  end
+  deprecate_class! :TSimpleMongrelHTTPServer => SimpleMongrelHTTPServer
+end

data/lib/thrift/server/nonblockingserver.rb

@@ -0,0 +1,278 @@
+require 'thrift/server'
+require 'logger'
+require 'thread'
+
+module Thrift
+  # this class expects to always use a FramedTransport for reading messages
+  class NonblockingServer < Server
+    def initialize(processor, serverTransport, transportFactory=nil, protocolFactory=nil, num=20, logger = nil)
+      super(processor, serverTransport, transportFactory, protocolFactory)
+      @num_threads = num
+      if logger.nil?
+        @logger = Logger.new(STDERR)
+        @logger.level = Logger::WARN
+      else
+        @logger = logger
+      end
+      @shutdown_semaphore = Mutex.new
+      @transport_semaphore = Mutex.new
+    end
+
+    def serve
+      @logger.info "Starting #{self}"
+      @serverTransport.listen
+      @io_manager = start_io_manager
+
+      begin
+        loop do
+          break if @serverTransport.closed?
+          rd, = select([@serverTransport], nil, nil, 0.1)
+          next if rd.nil?
+          socket = @serverTransport.accept
+          @logger.debug "Accepted socket: #{socket.inspect}"
+          @io_manager.add_connection socket
+        end
+      rescue IOError => e
+      end
+      # we must be shutting down
+      @logger.info "#{self} is shutting down, goodbye"
+    ensure
+      @transport_semaphore.synchronize do
+        @serverTransport.close
+      end
+      @io_manager.ensure_closed unless @io_manager.nil?
+    end
+
+    def shutdown(timeout = 0, block = true)
+      @shutdown_semaphore.synchronize do
+        return if @is_shutdown
+        @is_shutdown = true
+      end
+      # nonblocking is intended for calling from within a Handler
+      # but we can't change the order of operations here, so lets thread
+      shutdown_proc = lambda do
+        @io_manager.shutdown(timeout)
+        @transport_semaphore.synchronize do
+          @serverTransport.close # this will break the accept loop
+        end
+      end
+      if block
+        shutdown_proc.call
+      else
+        Thread.new &shutdown_proc
+      end
+    end
+
+    private
+
+    def start_io_manager
+      iom = IOManager.new(@processor, @serverTransport, @transportFactory, @protocolFactory, @num_threads, @logger)
+      iom.spawn
+      iom
+    end
+
+    class IOManager # :nodoc:
+      DEFAULT_BUFFER = 2**20
+      
+      def initialize(processor, serverTransport, transportFactory, protocolFactory, num, logger)
+        @processor = processor
+        @serverTransport = serverTransport
+        @transportFactory = transportFactory
+        @protocolFactory = protocolFactory
+        @num_threads = num
+        @logger = logger
+        @connections = []
+        @buffers = Hash.new { |h,k| h[k] = '' }
+        @signal_queue = Queue.new
+        @signal_pipes = IO.pipe
+        @signal_pipes[1].sync = true
+        @worker_queue = Queue.new
+        @shutdown_queue = Queue.new
+      end
+
+      def add_connection(socket)
+        signal [:connection, socket]
+      end
+
+      def spawn
+        @iom_thread = Thread.new do
+          @logger.debug "Starting #{self}"
+          run
+        end
+      end
+
+      def shutdown(timeout = 0)
+        @logger.debug "#{self} is shutting down workers"
+        @worker_queue.clear
+        @num_threads.times { @worker_queue.push [:shutdown] }
+        signal [:shutdown, timeout]
+        @shutdown_queue.pop
+        @signal_pipes[0].close
+        @signal_pipes[1].close
+        @logger.debug "#{self} is shutting down, goodbye"
+      end
+
+      def ensure_closed
+        kill_worker_threads if @worker_threads
+        @iom_thread.kill
+      end
+
+      private
+      
+      def run
+        spin_worker_threads
+
+        loop do
+          rd, = select([@signal_pipes[0], *@connections])
+          if rd.delete @signal_pipes[0]
+            break if read_signals == :shutdown
+          end
+          rd.each do |fd|
+            if fd.handle.eof?
+              remove_connection fd
+            else
+              read_connection fd
+            end
+          end
+        end
+        join_worker_threads(@shutdown_timeout)
+      ensure
+        @shutdown_queue.push :shutdown
+      end
+
+      def read_connection(fd)
+        @buffers[fd] << fd.read(DEFAULT_BUFFER)
+        frame = slice_frame!(@buffers[fd])
+        if frame
+          @logger.debug "#{self} is processing a frame"
+          @worker_queue.push [:frame, fd, frame]
+        end
+      end
+
+      def spin_worker_threads
+        @logger.debug "#{self} is spinning up worker threads"
+        @worker_threads = []
+        @num_threads.times do
+          @worker_threads << spin_thread
+        end
+      end
+
+      def spin_thread
+        Worker.new(@processor, @transportFactory, @protocolFactory, @logger, @worker_queue).spawn
+      end
+
+      def signal(msg)
+        @signal_queue << msg
+        @signal_pipes[1].write " "
+      end
+
+      def read_signals
+        # clear the signal pipe
+        # note that since read_nonblock is broken in jruby,
+        # we can only read up to a set number of signals at once
+        sigstr = @signal_pipes[0].readpartial(1024)
+        # now read the signals
+        begin
+          sigstr.length.times do
+            signal, obj = @signal_queue.pop(true)
+            case signal
+            when :connection
+              @connections << obj
+            when :shutdown
+              @shutdown_timeout = obj
+              return :shutdown
+            end
+          end
+        rescue ThreadError
+          # out of signals
+          # note that in a perfect world this would never happen, since we're
+          # only reading the number of signals pushed on the pipe, but given the lack
+          # of locks, in theory we could clear the pipe/queue while a new signal is being
+          # placed on the pipe, at which point our next read_signals would hit this error
+        end
+      end
+
+      def remove_connection(fd)
+        # don't explicitly close it, a thread may still be writing to it
+        @connections.delete fd
+        @buffers.delete fd
+      end
+
+      def join_worker_threads(shutdown_timeout)
+        start = Time.now
+        @worker_threads.each do |t|
+          if shutdown_timeout > 0
+            timeout = (start + shutdown_timeout) - Time.now
+            break if timeout <= 0
+            t.join(timeout)
+          else
+            t.join
+          end
+        end
+        kill_worker_threads
+      end
+
+      def kill_worker_threads
+        @worker_threads.each do |t|
+          t.kill if t.status
+        end
+        @worker_threads.clear
+      end
+
+      def slice_frame!(buf)
+        if buf.length >= 4
+          size = buf.unpack('N').first
+          if buf.length >= size + 4
+            buf.slice!(0, size + 4)
+          else
+            nil
+          end
+        else
+          nil
+        end
+      end
+
+      class Worker # :nodoc:
+        def initialize(processor, transportFactory, protocolFactory, logger, queue)
+          @processor = processor
+          @transportFactory = transportFactory
+          @protocolFactory = protocolFactory
+          @logger = logger
+          @queue = queue
+        end
+
+        def spawn
+          Thread.new do
+            @logger.debug "#{self} is spawning"
+            run
+          end
+        end
+
+        private
+
+        def run
+          loop do
+            cmd, *args = @queue.pop
+            case cmd
+            when :shutdown
+              @logger.debug "#{self} is shutting down, goodbye"
+              break
+            when :frame
+              fd, frame = args
+              begin
+                otrans = @transportFactory.get_transport(fd)
+                oprot = @protocolFactory.get_protocol(otrans)
+                membuf = MemoryBuffer.new(frame)
+                itrans = @transportFactory.get_transport(membuf)
+                iprot = @protocolFactory.get_protocol(itrans)
+                @processor.process(iprot, oprot)
+              rescue => e
+                @logger.error "#{Thread.current.inspect} raised error: #{e.inspect}\n#{e.backtrace.join("\n")}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thrift/server/thttpserver.rb

@@ -0,0 +1,2 @@
+require 'thrift/deprecation'
+require 'thrift/server/httpserver'

data/lib/thrift/server/tserver.rb

@@ -0,0 +1,2 @@
+require 'thrift/deprecation'
+require 'thrift/server'