garru-ruby_scribe_client 0.0.2

data/vendor/thrift/transport/httpclient.rb

@@ -0,0 +1,29 @@
+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/vendor/thrift/transport/socket.rb

@@ -0,0 +1,153 @@
+# 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/transport'
+require 'socket'
+
+module Thrift
+  class Socket < Transport
+    def initialize(host='localhost', port=9090, timeout=nil)
+      @host = host
+      @port = port
+      @timeout = timeout
+      @desc = "#{host}:#{port}"
+      @handle = nil
+    end
+
+    attr_accessor :handle, :timeout
+
+    def open
+      begin
+        @handle = TCPSocket.new(@host, @port)
+      rescue StandardError
+        raise TransportException.new(TransportException::NOT_OPEN, "Could not connect to #{@desc}")
+      end
+    end
+
+    def open?
+      !@handle.nil? and !@handle.closed?
+    end
+
+    def write(str)
+      raise IOError, "closed stream" unless open?
+      begin
+        if @timeout.nil? or @timeout == 0
+          @handle.write(str)
+        else
+          len = 0
+          start = Time.now
+          while Time.now - start < @timeout
+            rd, wr, = IO.select(nil, [@handle], nil, @timeout)
+            if wr and not wr.empty?
+              len += @handle.write_nonblock(str[len..-1])
+              break if len >= str.length
+            end
+          end
+          if len < str.length
+            raise TransportException.new(TransportException::TIMED_OUT, "Socket: Timed out writing #{str.length} bytes to #{@desc}")
+          else
+            len
+          end
+        end
+      rescue TransportException => e
+        # pass this on
+        raise e
+      rescue StandardError => e
+        @handle.close
+        @handle = nil
+        raise TransportException.new(TransportException::NOT_OPEN, e.message)
+      end
+    end
+
+    def read(sz)
+      raise IOError, "closed stream" unless open?
+
+      begin
+        if @timeout.nil? or @timeout == 0
+          data = @handle.readpartial(sz)
+        else
+          # it's possible to interrupt select for something other than the timeout
+          # so we need to ensure we've waited long enough
+          start = Time.now
+          rd = nil # scoping
+          loop do
+            rd, = IO.select([@handle], nil, nil, @timeout)
+            break if (rd and not rd.empty?) or Time.now - start >= @timeout
+          end
+          if rd.nil? or rd.empty?
+            raise TransportException.new(TransportException::TIMED_OUT, "Socket: Timed out reading #{sz} bytes from #{@desc}")
+          else
+            data = @handle.readpartial(sz)
+          end
+        end
+      rescue TransportException => e
+        # don't let this get caught by the StandardError handler
+        raise e
+      rescue StandardError => e
+        @handle.close unless @handle.closed?
+        @handle = nil
+        raise TransportException.new(TransportException::NOT_OPEN, e.message)
+      end
+      if (data.nil? or data.length == 0)
+        raise TransportException.new(TransportException::UNKNOWN, "Socket: Could not read #{sz} bytes from #{@desc}")
+      end
+      data
+    end
+
+    def close
+      @handle.close unless @handle.nil? or @handle.closed?
+      @handle = nil
+    end
+
+    def to_io
+      @handle
+    end
+  end
+  deprecate_class! :TSocket => Socket
+
+  class ServerSocket < ServerTransport
+    # call-seq: initialize(host = nil, port)
+    def initialize(host_or_port, port = nil)
+      if port
+        @host = host_or_port
+        @port = port
+      else
+        @host = nil
+        @port = host_or_port
+      end
+      @handle = nil
+    end
+
+    attr_reader :handle
+
+    def listen
+      @handle = TCPServer.new(@host, @port)
+    end
+
+    def accept
+      unless @handle.nil?
+        sock = @handle.accept
+        trans = Socket.new
+        trans.handle = sock
+        trans
+      end
+    end
+
+    def close
+     @handle.close unless @handle.nil? or @handle.closed?
+     @handle = nil
+    end
+
+    def closed?
+      @handle.nil? or @handle.closed?
+    end
+
+    alias to_io handle
+  end
+  deprecate_class! :TServerSocket => ServerSocket
+end

data/vendor/thrift/transport/thttpclient.rb

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

data/vendor/thrift/transport/tsocket.rb

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

data/vendor/thrift/transport/ttransport.rb

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

data/vendor/thrift/transport/unixsocket.rb

@@ -0,0 +1,58 @@
+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/vendor/thrift/transport.rb

@@ -0,0 +1,319 @@
+# 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/vendor/thrift/types.rb

@@ -0,0 +1,83 @@
+require 'set'
+
+module Thrift
+  module Types
+    STOP = 0
+    VOID = 1
+    BOOL = 2
+    BYTE = 3
+    DOUBLE = 4
+    I16 = 6
+    I32 = 8
+    I64 = 10
+    STRING = 11
+    STRUCT = 12
+    MAP = 13
+    SET = 14
+    LIST = 15
+  end
+  deprecate_module! :TType => Types
+
+  class << self
+    attr_accessor :type_checking
+  end
+
+  class TypeError < Exception
+  end
+
+  def self.check_type(value, field, name, skip_nil=true)
+    return if value.nil? and skip_nil
+    klasses = case field[:type]
+              when Types::VOID
+                NilClass
+              when Types::BOOL
+                [TrueClass, FalseClass]
+              when Types::BYTE, Types::I16, Types::I32, Types::I64
+                Integer
+              when Types::DOUBLE
+                Float
+              when Types::STRING
+                String
+              when Types::STRUCT
+                Struct
+              when Types::MAP
+                Hash
+              when Types::SET
+                Set
+              when Types::LIST
+                Array
+              end
+    valid = klasses && [*klasses].any? { |klass| klass === value }
+    raise TypeError, "Expected #{type_name(field[:type])}, received #{value.class} for field #{name}" unless valid
+    # check elements now
+    case field[:type]
+    when Types::MAP
+      value.each_pair do |k,v|
+        check_type(k, field[:key], "#{name}.key", false)
+        check_type(v, field[:value], "#{name}.value", false)
+      end
+    when Types::SET, Types::LIST
+      value.each do |el|
+        check_type(el, field[:element], "#{name}.element", false)
+      end
+    when Types::STRUCT
+      raise TypeError, "Expected #{field[:class]}, received #{value.class} for field #{name}" unless field[:class] == value.class
+    end
+  end
+
+  def self.type_name(type)
+    Types.constants.each do |const|
+      return "Types::#{const}" if Types.const_get(const) == type
+    end
+    nil
+  end
+
+  module MessageTypes
+    CALL = 1
+    REPLY = 2
+    EXCEPTION = 3
+  end
+  deprecate_module! :TMessageType => MessageTypes
+end
+
+Thrift.type_checking = false if Thrift.type_checking.nil?

data/vendor/thrift.rb

@@ -0,0 +1,28 @@
+#
+# 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>
+#
+
+$:.unshift File.dirname(__FILE__)
+
+module Thrift
+  # prevent the deprecation layer from being loaded if you require 'thrift'
+  DEPRECATION = false unless const_defined? :DEPRECATION
+end
+
+require 'thrift/deprecation'
+require 'thrift/exceptions'
+require 'thrift/types'
+require 'thrift/processor'
+require 'thrift/client'
+require 'thrift/struct'
+require 'thrift/protocol'
+require 'thrift/protocol/binaryprotocol'
+require 'thrift/transport'
+require 'thrift/transport/socket'
+require 'thrift/server'