thrift 0.0.751142 → 0.0.810255.1

data/lib/thrift/deprecation.rb

@@ -1,155 +0,0 @@
-# provide a backwards-compatible wrapper API and deprecate it
-
-module Thrift
-  DEPRECATION = true unless const_defined?(:DEPRECATION)
-end
-
-class Module
-  # Wraps the given methods to print a warning and call the real method
-  # Example:
-  #   deprecate! :readAll => :read_all
-  #--
-  # Yeah, this is ugly, passing a string to module_eval, but unfortunately
-  # using a block removes the ability to pass blocks to the defined method
-  # and breaks spec
-  def deprecate!(methods)
-    return unless Thrift::DEPRECATION
-    methods.each_pair do |old, new|
-      module_eval <<-EOF
-        def #{old}(*args, &block)
-          old, new = #{[old,new].inspect}
-          STDERR.puts "Warning: calling deprecated method \#{self.is_a?(Module) ? "\#{self}." : "\#{self.class}#"}\#{old}"
-          STDERR.puts "  from \#{caller.first}"
-          target = (self.is_a?(Module) ? (class << self;self;end) : self.class)
-          target.send :define_method, old, target.instance_method(new) # unwrap
-          target.instance_method(new).bind(self).call(*args, &block)
-        end
-      EOF
-    end
-  end
-end
-
-module Thrift::DeprecationProxy # :nodoc:
-  # there's a really weird bug in Ruby where class variables behave wrong
-  # when used in a Class.new or #class_eval rather than in a class foo block.
-  CLASS_MAPPING = {}
-  MODULE_MAPPING = {}
-  def self.new_class(obj, name)
-    klass_id = CLASS_MAPPING.size
-    CLASS_MAPPING[klass_id] = [obj, name, true]
-    klass = Class.new(obj) do
-      klass = self
-      instance_methods.sort.reject { |x| [:__id__,:__send__].include? x.to_sym }.each do |sym|
-        undef_method sym
-      end
-      define_method :__thrift_deprecation_proxy_klass_id do
-        klass_id
-      end
-      def method_missing(sym, *args, &block)
-        klass_id = __thrift_deprecation_proxy_klass_id
-        obj, name, warned = CLASS_MAPPING[klass_id]
-        obj.instance_method(sym).bind(self).call(*args, &block)
-      end
-      (class << self;self;end).class_eval do
-        instance_methods.sort.reject { |x| [:__id__,:__send__].include? x.to_sym }.each do |sym|
-          undef_method sym
-        end
-        define_method :__thrift_deprecation_proxy_klass do
-          [klass, klass_id]
-        end
-        def method_missing(sym, *args, &block)
-          klass, klass_id = __thrift_deprecation_proxy_klass
-          obj, name, warned = CLASS_MAPPING[klass_id]
-          unless warned
-            STDERR.puts "Warning: class #{name} is deprecated"
-            STDERR.puts "  from #{Thrift::DeprecationProxy.process_caller(caller)}"
-            CLASS_MAPPING[klass_id][2] = true
-          end
-          if klass.__id__ == self.__id__
-            obj.send sym, *args, &block
-          else
-            obj.method(sym).unbind.bind(self).call(*args, &block)
-          end
-        end
-      end
-    end
-    CLASS_MAPPING[klass_id][2] = false
-    klass
-  end
-  def self.new_module(obj, name)
-    mod_id = MODULE_MAPPING.size
-    MODULE_MAPPING[mod_id] = [obj, name, true]
-    mod = Module.new do
-      include obj
-      instance_methods.sort.reject { |x| [:__id__,:__send__].include? x.to_sym }.each do |sym|
-        undef_method sym
-      end
-      define_method :__thrift_deprecation_proxy_module_id do
-        mod_id
-      end
-      def method_missing(sym, *args, &block)
-        mod_id = __thrift_deprecation_proxy_module_id
-        obj, name, warned = MODULE_MAPPING[mod_id]
-        unless warned
-          STDERR.puts "Warning: module #{name} is deprecated"
-          STDERR.puts "  from #{Thrift::DeprecationProxy.process_caller(caller)}"
-          MODULE_MAPPING[mod_id][2] = true
-        end
-        obj.instance_method(sym).bind(self).call(*args, &block)
-      end
-      (class << self;self;end).class_eval do
-        instance_methods.sort.reject { |x| [:__id__,:__send__].include? x.to_sym }.each do |sym|
-          undef_method sym
-        end
-        define_method :__thrift_deprecation_proxy_module_id do
-          mod_id
-        end
-        def method_missing(sym, *args, &block)
-          mod_id = __thrift_deprecation_proxy_module_id
-          obj, name, warned = MODULE_MAPPING[mod_id]
-          unless warned
-            STDERR.puts "Warning: module #{name} is deprecated"
-            STDERR.puts "  from #{Thrift::DeprecationProxy.process_caller(caller)}"
-            MODULE_MAPPING[mod_id][2] = true
-          end
-          obj.send sym, *args, &block
-        end
-      end
-    end
-    MODULE_MAPPING[mod_id][2] = false
-    mod
-  end
-  def self.process_caller(stack)
-    dir = File.dirname(__FILE__)
-    stack.find { |frame| frame[0,dir.size] != dir }
-  end
-  def self.reset_deprecation_warnings
-    CLASS_MAPPING.each { |k,v| v[2] = false }
-    MODULE_MAPPING.each { |k,v| v[2] = false }
-  end
-end
-
-module Kernel
-  # Provides an alternate name for the class for deprecation purposes
-  # Example:
-  #   deprecate_class! :TBinaryProtocol => Thrift::BinaryProtocol
-  #--
-  # at the moment this only works for creating top-level constants
-  # if necessary, this can be extended to take something like :'Thrift::TBinaryProtocol'
-  # alternately, Module can be extended with a similar method
-  def deprecate_class!(klasses)
-    return unless Thrift::DEPRECATION
-    klasses.each_pair do |old, new|
-      raise "deprecate_class! expected Class, called with #{new}" unless new.is_a? Class
-      Object.const_set old, Thrift::DeprecationProxy.new_class(new, old)
-    end
-  end
-
-  # like deprecate_class! but for Modules
-  def deprecate_module!(modules)
-    return unless Thrift::DEPRECATION
-    modules.each_pair do |old, new|
-      Object.const_set old, Thrift::DeprecationProxy.new_module(new, old)
-    end
-  end
-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/protocol.rb

@@ -1,270 +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>
-#
-
-# 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

@@ -1,27 +0,0 @@
-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/thttpserver.rb

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

data/lib/thrift/server/tserver.rb

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

data/lib/thrift/server.rb

@@ -1,135 +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'
-require 'thrift/protocol/binaryprotocol'
-require 'thrift/transport'
-
-module Thrift
-  class Server
-    def initialize(processor, serverTransport, transportFactory=nil, protocolFactory=nil)
-      @processor = processor
-      @serverTransport = serverTransport
-      @transportFactory = transportFactory ? transportFactory : Thrift::TransportFactory.new
-      @protocolFactory = protocolFactory ? protocolFactory : Thrift::BinaryProtocolFactory.new
-    end
-
-    def serve; nil; end
-  end
-  deprecate_class! :TServer => Server
-
-  class SimpleServer < Server
-    def serve
-      begin
-        @serverTransport.listen
-        loop do
-          client = @serverTransport.accept
-          trans = @transportFactory.get_transport(client)
-          prot = @protocolFactory.get_protocol(trans)
-          begin
-            loop do
-              @processor.process(prot, prot)
-            end
-          rescue Thrift::TransportException, Thrift::ProtocolException
-          ensure
-            trans.close
-          end
-        end
-      ensure
-        @serverTransport.close
-      end
-    end
-  end
-  deprecate_class! :TSimpleServer => SimpleServer
-end
-
-# do *not* use fastthread
-# it has a bug that triggers on NonblockingServer
-require 'thread'
-
-module Thrift
-  class ThreadedServer < Server
-    def serve
-      begin
-        @serverTransport.listen
-        loop do
-          client = @serverTransport.accept
-          trans = @transportFactory.get_transport(client)
-          prot = @protocolFactory.get_protocol(trans)
-          Thread.new(prot, trans) do |p, t|
-            begin
-              loop do
-                @processor.process(p, p)
-              end
-            rescue Thrift::TransportException, Thrift::ProtocolException
-            ensure
-              t.close
-            end
-          end
-        end
-      ensure
-        @serverTransport.close
-      end
-    end
-  end
-  deprecate_class! :TThreadedServer => ThreadedServer
-
-  class ThreadPoolServer < Server
-    def initialize(processor, serverTransport, transportFactory=nil, protocolFactory=nil, num=20)
-      super(processor, serverTransport, transportFactory, protocolFactory)
-      @thread_q = SizedQueue.new(num)
-      @exception_q = Queue.new
-      @running = false
-    end
-
-    ## exceptions that happen in worker threads will be relayed here and
-    ## must be caught. 'retry' can be used to continue. (threads will
-    ## continue to run while the exception is being handled.)
-    def rescuable_serve
-      Thread.new { serve } unless @running
-      @running = true
-      raise @exception_q.pop
-    end
-
-    ## exceptions that happen in worker threads simply cause that thread
-    ## to die and another to be spawned in its place.
-    def serve
-      @serverTransport.listen
-
-      begin
-        loop do
-          @thread_q.push(:token)
-          Thread.new do
-            begin
-              loop do
-                client = @serverTransport.accept
-                trans = @transportFactory.get_transport(client)
-                prot = @protocolFactory.get_protocol(trans)
-                begin
-                  loop do
-                    @processor.process(prot, prot)
-                  end
-                rescue Thrift::TransportException, Thrift::ProtocolException => e
-                ensure
-                  trans.close
-                end
-              end
-            rescue => e
-              @exception_q.push(e)
-            ensure
-              @thread_q.pop # thread died!
-            end
-          end
-        end
-      ensure
-        @serverTransport.close
-      end
-    end
-  end
-  deprecate_class! :TThreadPoolServer => ThreadPoolServer
-end

data/lib/thrift/thrift.rb

@@ -1,14 +0,0 @@
-# This file kept for backwards compatability
-# require File.join(File.dirname(__FILE__), '../thrift')
-$:.unshift File.dirname(File.dirname(__FILE__))
-require 'thrift/deprecation'
-require 'thrift/types'
-require 'thrift/processor'
-require 'thrift/exceptions'
-require 'thrift/client'
-require 'thrift/struct'
-begin
-  require "thrift_native"
-rescue
-  puts "Could not load thrift_native libraries. Using pure ruby version."
-end

data/lib/thrift/transport/httpclient.rb

@@ -1,29 +0,0 @@
-require 'thrift/transport'
-
-require 'net/http'
-require 'net/https'
-require 'uri'
-require 'stringio'
-
-## Very simple HTTP client
-module Thrift
-  class HTTPClient < Transport
-    def initialize(url)
-      @url = URI url
-      @outbuf = ""
-    end
-
-    def open?; true end
-    def read(sz); @inbuf.read sz end
-    def write(buf); @outbuf << buf end
-    def flush
-      http = Net::HTTP.new @url.host, @url.port
-      http.use_ssl = @url.scheme == "https"
-      headers = { 'Content-Type' => 'application/x-thrift' }
-      resp, data = http.post(@url.path, @outbuf, headers)
-      @inbuf = StringIO.new data
-      @outbuf = ""
-    end
-  end
-  deprecate_class! :THttpClient => HTTPClient
-end

data/lib/thrift/transport/thttpclient.rb

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

data/lib/thrift/transport/tsocket.rb

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

data/lib/thrift/transport/ttransport.rb

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