thrift 0.0.751142 → 0.0.810255.1

data/lib/thrift/transport/unixsocket.rb

@@ -1,58 +0,0 @@
-require 'thrift/transport'
-require 'socket'
-
-module Thrift
-  class UNIXSocket < Socket
-    def initialize(path, timeout=nil)
-      @path = path
-      @timeout = timeout
-      @desc = @path # for read()'s error
-      @handle = nil
-    end
-
-    def open
-      begin
-        @handle = ::UNIXSocket.new(@path)
-      rescue StandardError
-        raise TransportException.new(TransportException::NOT_OPEN, "Could not open UNIX socket at #{@path}")
-      end
-    end
-  end
-
-  class UNIXServerSocket < ServerTransport
-    def initialize(path)
-      @path = path
-      @handle = nil
-    end
-
-    attr_accessor :handle
-
-    def listen
-      @handle = ::UNIXServer.new(@path)
-    end
-
-    def accept
-      unless @handle.nil?
-        sock = @handle.accept
-        trans = UNIXSocket.new(nil)
-        trans.handle = sock
-        trans
-      end
-    end
-
-    def close
-      if @handle
-        @handle.close unless @handle.closed?
-        @handle = nil
-        # UNIXServer doesn't delete the socket file, so we have to do it ourselves
-        File.delete(@path)
-      end
-    end
-
-    def closed?
-      @handle.nil? or @handle.closed?
-    end
-
-    alias to_io handle
-  end
-end

data/lib/thrift/transport.rb

@@ -1,319 +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>
-#
-
-module Thrift
-  class TransportException < Exception
-    UNKNOWN = 0
-    NOT_OPEN = 1
-    ALREADY_OPEN = 2
-    TIMED_OUT = 3
-    END_OF_FILE = 4
-
-    attr_reader :type
-
-    def initialize(type=UNKNOWN, message=nil)
-      super(message)
-      @type = type
-    end
-  end
-  deprecate_class! :TTransportException => TransportException
-
-# Transport is basically an abstract class, but isn't raising NotImplementedError
-# TODO: Think about if this is the right thing - Kevin Clark - 3/27/08
-  class Transport
-    def open?; end
-    deprecate! :isOpen => :open?
-    deprecate! :is_open? => :open?
-
-    def open; end
-
-    def close; end
-
-    def read(sz); end
-
-    def read_all(size)
-      buf = ''
-    
-      while (buf.length < size)
-        chunk = read(size - buf.length)
-        buf << chunk
-      end
-    
-      buf
-    end
-    deprecate! :readAll => :read_all
-  
-    def write(buf); end
-    alias_method :<<, :write
-
-    def flush; end
-  end
-  deprecate_class! :TTransport => Transport
-
-  class ServerTransport
-    def listen; nil; end
-
-    def accept; nil; end
-
-    def close; nil; end
-
-    def closed?; nil; end
-  end
-  deprecate_class! :TServerTransport => ServerTransport
-
-  class TransportFactory
-    def get_transport(trans)
-      return trans
-    end
-    deprecate! :getTransport => :get_transport
-  end
-  deprecate_class! :TTransportFactory => TransportFactory
-
-  class BufferedTransport < Transport
-    DEFAULT_BUFFER = 4096
-    
-    def initialize(transport)
-      @transport = transport
-      @wbuf = ''
-      @rbuf = ''
-    end
-
-    def open?
-      return @transport.open?
-    end
-
-    def open
-      @transport.open
-    end
-
-    def close
-      flush
-      @transport.close
-    end
-
-    def read(sz)
-      ret = @rbuf.slice!(0...sz) 
-      if ret.length == 0
-        @rbuf = @transport.read([sz, DEFAULT_BUFFER].max) 
-        @rbuf.slice!(0...sz) 
-      else 
-        ret 
-      end
-    end
-
-    def write(buf)
-      @wbuf << buf
-    end
-
-    def flush
-      if @wbuf != ''
-        @transport.write(@wbuf)
-        @wbuf = ''
-      end
-      
-      @transport.flush
-    end
-
-    def borrow(requested_length = 0)
-      # $stderr.puts "#{Time.now.to_f} Have #{@rbuf.length} asking for #{requested_length.inspect}"
-      return @rbuf if @rbuf.length > requested_length
-      
-      if @rbuf.length < DEFAULT_BUFFER
-        @rbuf << @transport.read([requested_length, DEFAULT_BUFFER].max)
-      end
-      
-      if @rbuf.length < requested_length
-        @rbuf << @transport.read_all(requested_length - @rbuf.length)
-      end
-    
-      @rbuf
-    end
-    
-    def consume!(size)
-      @rbuf.slice!(0...size)
-    end
-  end
-  deprecate_class! :TBufferedTransport => BufferedTransport
-
-  class BufferedTransportFactory < TransportFactory
-    def get_transport(transport)
-      return BufferedTransport.new(transport)
-    end
-  end
-  deprecate_class! :TBufferedTransportFactory => BufferedTransportFactory
-
-  class FramedTransport < Transport
-    def initialize(transport, read=true, write=true)
-      @transport = transport
-      @rbuf      = ''
-      @wbuf      = ''
-      @read      = read
-      @write     = write
-    end
-
-    def open?
-      @transport.open?
-    end
-
-    def open
-      @transport.open
-    end
-
-    def close
-      @transport.close
-    end
-
-    def read(sz)
-      return @transport.read(sz) unless @read
-
-      return '' if sz <= 0
-
-      read_frame if @rbuf.empty?
-
-      @rbuf.slice!(0, sz)
-    end
-
-    def write(buf,sz=nil)
-      return @transport.write(buf) unless @write
-
-      @wbuf << (sz ? buf[0...sz] : buf)
-    end
-
-    #
-    # Writes the output buffer to the stream in the format of a 4-byte length
-    # followed by the actual data.
-    #
-    def flush
-      return @transport.flush unless @write
-
-      out = [@wbuf.length].pack('N')
-      out << @wbuf
-      @transport.write(out)
-      @transport.flush
-      @wbuf = ''
-    end
-
-    def borrow(requested_length = 0)
-      read_frame if @rbuf.empty?
-      # there isn't any more coming, so if it's not enough, it's an error.
-      raise EOFError if requested_length > @rbuf.size
-      @rbuf
-    end
-    
-    def consume!(size)
-      @rbuf.slice!(0...size)
-    end
-
-    private
-
-    def read_frame
-      sz = @transport.read_all(4).unpack('N').first
-
-      @rbuf = @transport.read_all(sz).dup # protect against later #slice!
-    end
-  end
-  deprecate_class! :TFramedTransport => FramedTransport
-
-  class FramedTransportFactory < TransportFactory
-    def get_transport(transport)
-      return FramedTransport.new(transport)
-    end
-  end
-  deprecate_class! :TFramedTransportFactory => FramedTransportFactory
-
-  class MemoryBuffer < Transport
-    GARBAGE_BUFFER_SIZE = 4*(2**10) # 4kB
-
-    # If you pass a string to this, you should #dup that string
-    # unless you want it to be modified by #read and #write
-    #--
-    # this behavior is no longer required. If you wish to change it
-    # go ahead, just make sure the specs pass
-    def initialize(buffer = nil)
-      @buf = buffer || ''
-      @index = 0
-    end
-
-    def open?
-      return true
-    end
-
-    def open
-    end
-
-    def close
-    end
-
-    def peek
-      @index < @buf.size
-    end
-
-    # this method does not use the passed object directly but copies it
-    def reset_buffer(new_buf = '')
-      @buf.replace new_buf
-      @index = 0
-    end
-
-    def available
-      @buf.length - @index
-    end
-
-    def read(len)
-      data = @buf.slice(@index, len)
-      @index += len
-      @index = @buf.size if @index > @buf.size
-      if @index >= GARBAGE_BUFFER_SIZE
-        @buf = @buf.slice(@index..-1)
-        @index = 0
-      end
-      data
-    end
-
-    def write(wbuf)
-      @buf << wbuf
-    end
-
-    def flush
-    end
-
-    # For fast binary protocol access
-    def borrow(size = nil)
-      if size.nil?
-        @buf[@index..-1]
-      else
-        if size > available
-          raise EOFError # Memory buffers only get one shot.
-        else
-          @buf[@index, size]
-        end
-      end
-    end
-
-    alias_method :consume!, :read
-  end
-  deprecate_class! :TMemoryBuffer => MemoryBuffer
-
-  ## Very very simple implementation of wrapping two objects, one with a #read
-  ## method and one with a #write method, into a transport for thrift.
-  ##
-  ## Assumes both objects are open, remain open, don't require flushing, etc.
-  class IOStreamTransport < Transport
-    def initialize(input, output)
-      @input = input
-      @output = output
-    end
-
-    def open?; not @input.closed? or not @output.closed? end
-    def read(sz); @input.read(sz) end
-    def write(buf); @output.write(buf) end
-    def close; @input.close; @output.close end
-    def to_io; @input end # we're assuming this is used in a IO.select for reading
-  end
-  deprecate_class! :TIOStreamTransport => IOStreamTransport
-end

data/spec/backwards_compatibility_spec.rb

@@ -1,136 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require 'thrift/protocol/binaryprotocol'
-require 'thrift/server/httpserver'
-require 'thrift/transport/httpclient'
-
-context "Backwards compatibility" do
-  specify "old class names should map to new classes" do
-    Thrift::DeprecationProxy.reset_deprecation_warnings
-    # use an Array because a Hash will call #hash and trigger deprecation warnings
-    klasses = [
-      [:module, :ThriftClient,               Thrift::Client],
-      [:class,  :TException,                 Thrift::Exception],
-      [:class,  :TApplicationException,      Thrift::ApplicationException],
-      [:module, :TProcessor,                 Thrift::Processor],
-      [:class,  :TProtocolException,         Thrift::ProtocolException],
-      [:class,  :TProtocol,                  Thrift::Protocol],
-      [:class,  :TProtocolFactory,           Thrift::ProtocolFactory],
-      [:class,  :TBinaryProtocol,            Thrift::BinaryProtocol],
-      [:class,  :TBinaryProtocolFactory,     Thrift::BinaryProtocolFactory],
-      [:class,  :TSimpleMongrelHTTPServer,   Thrift::SimpleMongrelHTTPServer],
-      [:class,  :TServer,                    Thrift::Server],
-      [:class,  :TSimpleServer,              Thrift::SimpleServer],
-      [:class,  :TThreadedServer,            Thrift::ThreadedServer],
-      [:class,  :TThreadPoolServer,          Thrift::ThreadPoolServer],
-      [:module, :ThriftStruct,               Thrift::Struct],
-      [:class,  :THttpClient,                Thrift::HTTPClient],
-      [:class,  :TSocket,                    Thrift::Socket],
-      [:class,  :TServerSocket,              Thrift::ServerSocket],
-      [:class,  :TTransportException,        Thrift::TransportException],
-      [:class,  :TTransport,                 Thrift::Transport],
-      [:class,  :TServerTransport,           Thrift::ServerTransport],
-      [:class,  :TTransportFactory,          Thrift::TransportFactory],
-      [:class,  :TBufferedTransport,         Thrift::BufferedTransport],
-      [:class,  :TBufferedTransportFactory,  Thrift::BufferedTransportFactory],
-      [:class,  :TFramedTransport,           Thrift::FramedTransport],
-      [:class,  :TFramedTransportFactory,    Thrift::FramedTransportFactory],
-      [:class,  :TMemoryBuffer,              Thrift::MemoryBuffer],
-      [:class,  :TIOStreamTransport,         Thrift::IOStreamTransport],
-      [:module, :TType,                      Thrift::Types],
-      [:module, :TMessageType,               Thrift::MessageTypes]
-    ]
-    klasses.each do |(type, oldname, newklass)|
-      oldklass = Object.const_get(oldname)
-      STDERR.should_receive(:puts).with("Warning: #{type} #{oldname} is deprecated").ordered
-      STDERR.should_receive(:puts).with("  from #{__FILE__}:#{__LINE__+1}").ordered
-      oldklass.should eql(newklass)
-      STDERR.rspec_verify
-      STDERR.rspec_reset
-    end
-  end
-
-  specify "old method names should map to new method names" do
-    mapping = {
-      Thrift::Protocol => {
-        :writeMessageBegin => :write_message_begin,
-        :writeMessageEnd => :write_message_end,
-        :writeStructBegin => :write_struct_begin,
-        :writeStructEnd => :write_struct_end,
-        :writeFieldBegin => :write_field_begin,
-        :writeFieldEnd => :write_field_end,
-        :writeFieldStop => :write_field_stop,
-        :writeMapBegin => :write_map_begin,
-        :writeMapEnd => :write_map_end,
-        :writeListBegin => :write_list_begin,
-        :writeListEnd => :write_list_end,
-        :writeSetBegin => :write_set_begin,
-        :writeSetEnd => :write_set_end,
-        :writeBool => :write_bool,
-        :writeByte => :write_byte,
-        :writeI16 => :write_i16,
-        :writeI32 => :write_i32,
-        :writeI64 => :write_i64,
-        :writeDouble => :write_double,
-        :writeString => :write_string,
-        :readMessageBegin => :read_message_begin,
-        :readMessageEnd => :read_message_end,
-        :readStructBegin => :read_struct_begin,
-        :readStructEnd => :read_struct_end,
-        :readFieldBegin => :read_field_begin,
-        :readFieldEnd => :read_field_end,
-        :readMapBegin => :read_map_begin,
-        :readMapEnd => :read_map_end,
-        :readListBegin => :read_list_begin,
-        :readListEnd => :read_list_end,
-        :readSetBegin => :read_set_begin,
-        :readSetEnd => :read_set_end,
-        :readBool => :read_bool,
-        :readByte => :read_byte,
-        :readI16 => :read_i16,
-        :readI32 => :read_i32,
-        :readI64 => :read_i64,
-        :readDouble => :read_double,
-        :readString => :read_string
-      },
-      Thrift::ProtocolFactory => {
-        :getProtocol => :get_protocol
-      },
-      Thrift::Transport => {
-        :isOpen => :open?,
-        :is_open? => :open?,
-        :readAll => :read_all
-      },
-      Thrift::TransportFactory => {
-        :getTransport => :get_transport
-      }
-    }
-    STDERR.stub!(:puts) # stub the deprecation warnings
-    mapping.each_pair do |klass, methods|
-      # save these so they can be used after being mocked up
-      defn_method = klass.method(:define_method)
-      inst_method = klass.method(:instance_method)
-      methods.each_pair do |oldmeth, newmeth|
-        # ensure that calling the old method will call the new method
-        # and then redefine the old method to be the new one
-        klass.should be_method_defined(oldmeth)
-        klass.should be_method_defined(newmeth)
-        orig_method = inst_method.call(:initialize)
-        defn_method.call(:initialize, proc {} ) # stub out initialize
-        begin
-          mockmeth = mock("UnboundMethod: #{newmeth}")
-          mockmeth.should_receive(:bind).and_return do
-            mock("Method: #{newmeth}").tee do |meth|
-              meth.should_receive(:call)
-            end
-          end
-          klass.should_receive(:instance_method).with(newmeth).twice.and_return(mockmeth)
-          klass.should_receive(:define_method).with(oldmeth, mockmeth)
-          klass.new.send oldmeth
-          klass.rspec_verify
-        ensure
-          defn_method.call(:initialize, orig_method)
-        end
-      end
-    end
-  end
-end

data/spec/binaryprotocolaccelerated_spec.rb

@@ -1,101 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require 'thrift/protocol/binaryprotocolaccelerated'
-require File.dirname(__FILE__) + '/binaryprotocol_spec_shared'
-require File.dirname(__FILE__) + '/gen-rb/ThriftSpec_types'
-
-class ThriftBinaryProtocolAcceleratedSpec < Spec::ExampleGroup
-  include Thrift
-
-  describe Thrift::BinaryProtocolAccelerated do
-    # since BinaryProtocolAccelerated should be directly equivalent to 
-    # BinaryProtocol, we don't need any custom specs!
-    it_should_behave_like 'a binary protocol'
-
-    def protocol_class
-      BinaryProtocolAccelerated
-    end
-
-#     before(:each) do
-#       @buffer = ""
-#       @trans.stub!(:borrow).and_return { @buffer }
-#       @trans.stub!(:consume!).and_return do |*args|
-#         n = args.first || 0
-#         @buffer.slice!(0,n)
-#       end
-#     end
-# 
-# 
-#     it "should raise an exception if the message header has the wrong version" do
-#       @buffer = "\000\000\000\v"
-#       # @prot.should_receive(:read_i32).and_return(42)
-#       lambda { @prot.read_message_begin }.should raise_error(Thrift::ProtocolException, 'Missing version identifier') do |e|
-#         e.type == Thrift::ProtocolException::BAD_VERSION
-#       end
-#     end
-# 
-#     it "should encode a string with null bytes in it" do
-#       foo = SpecNamespace::Hello.new(:greeting => "Hello\000World!")
-#       @prot.encode_binary(foo).should == "\v\000\001\000\000\000\fHello\000World!\000"
-#     end
-# 
-#     it "should decode a string with null bytes in it" do
-#       trans = Thrift::MemoryBuffer.new("\v\000\001\000\000\000\fHello\000World!\000")
-#       @prot.decode_binary(SpecNamespace::Hello.new, trans).should == SpecNamespace::Hello.new(:greeting => "Hello\000World!")
-#     end
-# 
-#     it "should error when encoding a struct with a nil value in a list" do
-#       Thrift.type_checking = false
-#       sl = SpecNamespace::SimpleList
-#       hello = SpecNamespace::Hello
-#       # nil counts as false for bools
-#       # lambda { @prot.encode_binary(sl.new(:bools => [true, false, nil, false])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:bytes => [1, 2, nil, 3])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:i16s => [1, 2, nil, 3])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:i32s => [1, 2, nil, 3])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:i64s => [1, 2, nil, 3])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:doubles => [1.0, 2.0, nil, 3.0])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:strings => ["one", "two", nil, "three"])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:lists => [[1, 2], nil, [3, 4]])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:maps => [{1 => 2}, nil, {3 => 4}])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:sets => [Set.new([1, 2]), nil, Set.new([3, 4])])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:structs => [hello.new, nil, hello.new(:greeting => "hi")])) }.should raise_error
-#     end
-# 
-#     it "should error when encoding a non-nil, non-correctly-typed value in a list" do
-#       Thrift.type_checking = false
-#       sl = SpecNamespace::SimpleList
-#       hello = SpecNamespace::Hello
-#       # bool should accept any value
-#       # lambda { @prot.encode_binary(sl.new(:bools => [true, false, 3])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:bytes => [1, 2, "3", 5])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:i16s => ["one", 2, 3])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:i32s => [[1,2], 3, 4])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:i64s => [{1 => 2}, 3, 4])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:doubles => ["one", 2.3, 3.4])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:strings => ["one", "two", 3, 4])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:lists => [{1 => 2}, [3, 4]])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:maps => [{1 => 2}, [3, 4]])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:sets => [Set.new([1, 2]), 3, 4])) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:structs => [3, "four"])) }.should raise_error
-#     end
-# 
-#     it "should error when encoding an improper object where a container is expected" do
-#       Thrift.type_checking = false
-#       sl = SpecNamespace::SimpleList
-#       lambda { @prot.encode_binary(sl.new(:strings => {"one" => "two", nil => "three"})) }.should raise_error
-#       lambda { @prot.encode_binary(sl.new(:maps => [[1, 2]])) }.should raise_error
-#     end
-# 
-#     it "should accept arrays and hashes as sets" do
-#       Thrift.type_checking = false
-#       sl = SpecNamespace::SimpleList
-#       lambda { @prot.encode_binary(sl.new(:sets => [[1, 2], {3 => true, 4 => true}])) }.should_not raise_error
-#     end
-  end
-
-  describe BinaryProtocolAcceleratedFactory do
-    it "should create a BinaryProtocolAccelerated" do
-      BinaryProtocolAcceleratedFactory.new.get_protocol(mock("MockTransport")).should be_instance_of(BinaryProtocolAccelerated)
-    end
-  end
-end