garru-ruby_scribe_client 0.0.2

data/vendor/thrift/protocol/binaryprotocol.rb

@@ -0,0 +1,213 @@
+#
+# 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/vendor/thrift/protocol/binaryprotocolaccelerated.rb

@@ -0,0 +1,19 @@
+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/vendor/thrift/protocol/tbinaryprotocol.rb

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

data/vendor/thrift/protocol/tprotocol.rb

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

data/vendor/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/vendor/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/vendor/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