thrift 0.2.0.4 → 0.4.0

data.tar.gz.sig

@@ -1,2 +0,0 @@
-Ť�E��1�].)� ��3i��s+�U������hc=D�����<��6^`�V�c"��\<�c�􅵌B��+��SLV���gOKxiڬ���œ�K|oa���rk�g�d���� ��
��FBQ�!���;��w��|�W(�6"���Ƹ�h����3�p!��oH��qh�����Q]+A=kM��d�-��E*�������M((KJm����qC��<�Ex���s����@���
-z�18

data/Makefile.am

@@ -1,47 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-EXTRA_DIST = \
-	CHANGELOG \
-	Rakefile \
-	Manifest \
-	setup.rb \
-	lib \
-	ext \
-	benchmark \
-	script \
-	spec
-
-all-local:
-	$(RUBY) setup.rb config
-	$(RUBY) setup.rb setup
-
-install-exec-hook:
-	$(RUBY) setup.rb install
-
-# Make sure this doesn't fail if Ruby is not configured.
-clean-local:
-	RUBY=$(RUBY) ; if test -z "$$RUBY" ; then RUBY=: ; fi ; \
-	$$RUBY setup.rb clean
-
-check-local: all
-if HAVE_RSPEC
-	rake spec
-endif
-

data/benchmark/gen-rb/BenchmarkService.rb

@@ -1,81 +0,0 @@
-#
-# Autogenerated by Thrift
-#
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-#
-
-require 'thrift'
-require 'thrift/protocol'
-require File.dirname(__FILE__) + '/Benchmark_types'
-
-    module ThriftBenchmark
-      module BenchmarkService
-        class Client
-          include ::Thrift::Client
-
-          def fibonacci(n)
-            send_fibonacci(n)
-            return recv_fibonacci()
-          end
-
-          def send_fibonacci(n)
-            send_message('fibonacci', Fibonacci_args, :n => n)
-          end
-
-          def recv_fibonacci()
-            result = receive_message(Fibonacci_result)
-            return result.success unless result.success.nil?
-            raise Thrift::ApplicationException.new(Thrift::ApplicationException::MISSING_RESULT, 'fibonacci failed: unknown result')
-          end
-
-        end
-
-        class Processor
-          include ::Thrift::Processor
-
-          def process_fibonacci(seqid, iprot, oprot)
-            args = read_args(iprot, Fibonacci_args)
-            result = Fibonacci_result.new()
-            result.success = @handler.fibonacci(args.n)
-            write_result(result, oprot, 'fibonacci', seqid)
-          end
-
-        end
-
-        # HELPER FUNCTIONS AND STRUCTURES
-
-        class Fibonacci_args
-          include ::Thrift::Struct
-          N = 1
-
-          Thrift::Struct.field_accessor self, :n
-          FIELDS = {
-            N => {:type => Thrift::Types::BYTE, :name => 'n'}
-          }
-
-          def struct_fields; FIELDS; end
-
-          def validate
-          end
-
-        end
-
-        class Fibonacci_result
-          include ::Thrift::Struct
-          SUCCESS = 0
-
-          Thrift::Struct.field_accessor self, :success
-          FIELDS = {
-            SUCCESS => {:type => Thrift::Types::I32, :name => 'success'}
-          }
-
-          def struct_fields; FIELDS; end
-
-          def validate
-          end
-
-        end
-
-      end
-
-    end

data/benchmark/gen-rb/Benchmark_constants.rb

@@ -1,11 +0,0 @@
-#
-# Autogenerated by Thrift
-#
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-#
-
-require 'thrift/protocol'
-require File.dirname(__FILE__) + '/Benchmark_types'
-
-  module ThriftBenchmark
-end

data/benchmark/gen-rb/Benchmark_types.rb

@@ -1,10 +0,0 @@
-#
-# Autogenerated by Thrift
-#
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-#
-
-require 'thrift/protocol'
-
-module ThriftBenchmark
-  end

data/lib/thrift/protocol/binaryprotocol.rb

@@ -1,213 +0,0 @@
-#
-# 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>
-#
-require 'thrift/protocol'
-
-module Thrift
-  class BinaryProtocol < Protocol
-    VERSION_MASK = 0xffff0000
-    VERSION_1 = 0x80010000
-    TYPE_MASK = 0x000000ff
-    
-    attr_reader :strict_read, :strict_write
-
-    def initialize(trans, strict_read=true, strict_write=true)
-      super(trans)
-      @strict_read = strict_read
-      @strict_write = strict_write
-    end
-
-    def write_message_begin(name, type, seqid)
-      # this is necessary because we added (needed) bounds checking to 
-      # write_i32, and 0x80010000 is too big for that.
-      if strict_write
-        write_i16(VERSION_1 >> 16)
-        write_i16(type)
-        write_string(name)
-        write_i32(seqid)
-      else
-        write_string(name)
-        write_byte(type)
-        write_i32(seqid)
-      end
-    end
-
-    def write_field_begin(name, type, id)
-      write_byte(type)
-      write_i16(id)
-    end
-
-    def write_field_stop
-      write_byte(Thrift::Types::STOP)
-    end
-
-    def write_map_begin(ktype, vtype, size)
-      write_byte(ktype)
-      write_byte(vtype)
-      write_i32(size)
-    end
-
-    def write_list_begin(etype, size)
-      write_byte(etype)
-      write_i32(size)
-    end
-
-    def write_set_begin(etype, size)
-      write_byte(etype)
-      write_i32(size)
-    end
-
-    def write_bool(bool)
-      write_byte(bool ? 1 : 0)
-    end
-
-    def write_byte(byte)
-      trans.write([byte].pack('c'))
-    end
-
-    def write_i16(i16)
-      trans.write([i16].pack('n'))
-    end
-
-    def write_i32(i32)
-      raise RangeError if i32 < -2**31 || i32 >= 2**31
-      trans.write([i32].pack('N'))
-    end
-
-    def write_i64(i64)
-      hi = i64 >> 32
-      lo = i64 & 0xffffffff
-      trans.write([hi, lo].pack('N2'))
-    end
-
-    def write_double(dub)
-      trans.write([dub].pack('G'))
-    end
-
-    def write_string(str)
-      write_i32(str.length)
-      trans.write(str)
-    end
-
-    def read_message_begin
-      version = read_i32
-      if version < 0
-        if (version & VERSION_MASK != VERSION_1)
-          raise ProtocolException.new(ProtocolException::BAD_VERSION, 'Missing version identifier')
-        end
-        type = version & TYPE_MASK
-        name = read_string
-        seqid = read_i32
-        [name, type, seqid]
-      else
-        if strict_read
-          raise ProtocolException.new(ProtocolException::BAD_VERSION, 'No version identifier, old protocol client?')
-        end
-        name = trans.read_all(version)
-        type = read_byte
-        seqid = read_i32
-        [name, type, seqid]
-      end
-    end
-
-    def read_field_begin
-      type = read_byte
-      if (type == Types::STOP)
-        [nil, type, 0]
-      else
-        id = read_i16
-        [nil, type, id]
-      end
-    end
-
-    def read_map_begin
-      ktype = read_byte
-      vtype = read_byte
-      size = read_i32
-      [ktype, vtype, size]
-    end
-
-    def read_list_begin
-      etype = read_byte
-      size = read_i32
-      [etype, size]
-    end
-
-    def read_set_begin
-      etype = read_byte
-      size = read_i32
-      [etype, size]
-    end
-
-    def read_bool
-      byte = read_byte
-      byte != 0
-    end
-
-    def read_byte
-      dat = trans.read_all(1)
-      val = dat[0]
-      if (val > 0x7f)
-        val = 0 - ((val - 1) ^ 0xff)
-      end
-      val
-    end
-
-    def read_i16
-      dat = trans.read_all(2)
-      val, = dat.unpack('n')
-      if (val > 0x7fff)
-        val = 0 - ((val - 1) ^ 0xffff)
-      end
-      val
-    end
-
-    def read_i32
-      dat = trans.read_all(4)
-      val, = dat.unpack('N')
-      if (val > 0x7fffffff)
-        val = 0 - ((val - 1) ^ 0xffffffff)
-      end
-      val
-    end
-
-    def read_i64
-      dat = trans.read_all(8)
-      hi, lo = dat.unpack('N2')
-      if (hi > 0x7fffffff)
-        hi ^= 0xffffffff
-        lo ^= 0xffffffff
-        0 - (hi << 32) - lo - 1
-      else
-        (hi << 32) + lo
-      end
-    end
-
-    def read_double
-      dat = trans.read_all(8)
-      val = dat.unpack('G').first
-      val
-    end
-
-    def read_string
-      sz = read_i32
-      dat = trans.read_all(sz)
-      dat
-    end
-
-  end
-  deprecate_class! :TBinaryProtocol => BinaryProtocol
-
-  class BinaryProtocolFactory < ProtocolFactory
-    def get_protocol(trans)
-      return Thrift::BinaryProtocol.new(trans)
-    end
-  end
-  deprecate_class! :TBinaryProtocolFactory => BinaryProtocolFactory
-end

data/lib/thrift/protocol/binaryprotocolaccelerated.rb

@@ -1,19 +0,0 @@
-require 'thrift/protocol/binaryprotocol'
-require 'thrift_native'
-
-=begin
-The only change required for a transport to support TBinaryProtocolAccelerated is to implement 2 methods:
-  * borrow(size), which takes an optional argument and returns atleast _size_ bytes from the transport, 
-                  or the default buffer size if no argument is given
-  * consume!(size), which removes size bytes from the front of the buffer
-
-See TMemoryBuffer and TBufferedTransport for examples.
-=end
-
-module Thrift
-  class BinaryProtocolAcceleratedFactory < ProtocolFactory
-    def get_protocol(trans)
-      BinaryProtocolAccelerated.new(trans)
-    end
-  end
-end

data/lib/thrift/protocol/tbinaryprotocol.rb

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

data/lib/thrift/protocol/tprotocol.rb

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

data/lib/thrift/server/httpserver.rb

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

@@ -1,278 +0,0 @@
-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