thrift 0.0.751142

data/lib/thrift/server.rb

@@ -0,0 +1,135 @@
+# 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/struct.rb

@@ -0,0 +1,272 @@
+require 'thrift/types'
+require 'set'
+
+module Thrift
+  module Struct
+    def initialize(d={})
+      # get a copy of the default values to work on, removing defaults in favor of arguments
+      fields_with_defaults = fields_with_default_values.dup
+      
+      # check if the defaults is empty, or if there are no parameters for this 
+      # instantiation, and if so, don't bother overriding defaults.
+      unless fields_with_defaults.empty? || d.empty?
+        d.each_key do |name|
+          fields_with_defaults.delete(name.to_s)
+        end
+      end
+      
+      # assign all the user-specified arguments
+      unless d.empty?
+        d.each do |name, value|
+          unless name_to_id(name.to_s)
+            raise Exception, "Unknown key given to #{self.class}.new: #{name}"
+          end
+          Thrift.check_type(value, struct_fields[name_to_id(name.to_s)], name) if Thrift.type_checking
+          instance_variable_set("@#{name}", value)
+        end
+      end
+      
+      # assign all the default values
+      unless fields_with_defaults.empty?
+        fields_with_defaults.each do |name, default_value|
+          instance_variable_set("@#{name}", (default_value.dup rescue default_value))
+        end
+      end
+    end
+
+    def fields_with_default_values
+      fields_with_default_values = self.class.instance_variable_get("@fields_with_default_values")
+      unless fields_with_default_values
+        fields_with_default_values = {}
+        struct_fields.each do |fid, field_def|
+          if field_def[:default]
+            fields_with_default_values[field_def[:name]] = field_def[:default]
+          end
+        end
+        self.class.instance_variable_set("@fields_with_default_values", fields_with_default_values)
+      end
+      fields_with_default_values
+    end
+
+    def name_to_id(name)
+      names_to_ids = self.class.instance_variable_get("@names_to_ids")
+      unless names_to_ids
+        names_to_ids = {}
+        struct_fields.each do |fid, field_def|
+          names_to_ids[field_def[:name]] = fid
+        end
+        self.class.instance_variable_set("@names_to_ids", names_to_ids)
+      end
+      names_to_ids[name]
+    end
+
+    # Obsoleted by THRIFT-246, which generates this method inline
+    # TODO: Should be removed at some point. -- Kevin Clark
+    def struct_fields
+      self.class.const_get(:FIELDS)
+    end
+
+    def each_field
+      struct_fields.each do |fid, data|
+        yield fid, data[:type], data[:name], data[:default], data[:optional]
+      end
+    end
+
+    def inspect(skip_optional_nulls = true)
+      fields = []
+      each_field do |fid, type, name, default, optional|
+        value = instance_variable_get("@#{name}")
+        unless skip_optional_nulls && optional && value.nil?
+          fields << "#{name}:#{value.inspect}"
+        end
+      end
+      "<#{self.class} #{fields.join(", ")}>"
+    end
+
+    def read(iprot)
+      # TODO(kevinclark): Make sure transport is C readable
+      if iprot.respond_to?(:decode_binary)
+        iprot.decode_binary(self, iprot.trans)
+      else
+        iprot.read_struct_begin
+        loop do
+          fname, ftype, fid = iprot.read_field_begin
+          break if (ftype == Types::STOP)
+          handle_message(iprot, fid, ftype)
+          iprot.read_field_end
+        end
+        iprot.read_struct_end
+      end
+      validate
+    end
+
+    def write(oprot)
+      validate
+      # if oprot.respond_to?(:encode_binary)
+      #   # TODO(kevinclark): Clean this so I don't have to access the transport.
+      #   oprot.trans.write oprot.encode_binary(self)
+      # else
+        oprot.write_struct_begin(self.class.name)
+        each_field do |fid, type, name|
+          unless (value = instance_variable_get("@#{name}")).nil?
+            if is_container? type
+              oprot.write_field_begin(name, type, fid)
+              write_container(oprot, value, struct_fields[fid])
+              oprot.write_field_end
+            else
+              oprot.write_field(name, type, fid, value)
+            end
+          end
+        end
+        oprot.write_field_stop
+        oprot.write_struct_end
+      # end
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      each_field do |fid, type, name, default|
+        return false unless self.instance_variable_get("@#{name}") == other.instance_variable_get("@#{name}")
+      end
+      true
+    end
+
+    def eql?(other)
+      self.class == other.class && self == other
+    end
+
+    # for the time being, we're ok with a naive hash. this could definitely be improved upon.
+    def hash
+      0
+    end
+
+    def self.field_accessor(klass, *fields)
+      fields.each do |field|
+        klass.send :attr_reader, field
+        klass.send :define_method, "#{field}=" do |value|
+          Thrift.check_type(value, klass::FIELDS.values.find { |f| f[:name].to_s == field.to_s }, field) if Thrift.type_checking
+          instance_variable_set("@#{field}", value)
+        end
+      end
+    end
+
+    protected
+
+    def self.append_features(mod)
+      if mod.ancestors.include? ::Exception
+        mod.send :class_variable_set, :'@@__thrift_struct_real_initialize', mod.instance_method(:initialize)
+        super
+        # set up our custom initializer so `raise Xception, 'message'` works
+        mod.send :define_method, :struct_initialize, mod.instance_method(:initialize)
+        mod.send :define_method, :initialize, mod.instance_method(:exception_initialize)
+      else
+        super
+      end
+    end
+
+    def exception_initialize(*args, &block)
+      if args.size == 1 and args.first.is_a? Hash
+        # looks like it's a regular Struct initialize
+        method(:struct_initialize).call(args.first)
+      else
+        # call the Struct initializer first with no args
+        # this will set our field default values
+        method(:struct_initialize).call()
+        # now give it to the exception
+        self.class.send(:class_variable_get, :'@@__thrift_struct_real_initialize').bind(self).call(*args, &block) if args.size > 0
+        # self.class.instance_method(:initialize).bind(self).call(*args, &block)
+      end
+    end
+
+    def handle_message(iprot, fid, ftype)
+      field = struct_fields[fid]
+      if field and field[:type] == ftype
+        value = read_field(iprot, field)
+        instance_variable_set("@#{field[:name]}", value)
+      else
+        iprot.skip(ftype)
+      end
+    end
+
+    def read_field(iprot, field = {})
+      case field[:type]
+      when Types::STRUCT
+        value = field[:class].new
+        value.read(iprot)
+      when Types::MAP
+        key_type, val_type, size = iprot.read_map_begin
+        value = {}
+        size.times do
+          k = read_field(iprot, field_info(field[:key]))
+          v = read_field(iprot, field_info(field[:value]))
+          value[k] = v
+        end
+        iprot.read_map_end
+      when Types::LIST
+        e_type, size = iprot.read_list_begin
+        value = Array.new(size) do |n|
+          read_field(iprot, field_info(field[:element]))
+        end
+        iprot.read_list_end
+      when Types::SET
+        e_type, size = iprot.read_set_begin
+        value = Set.new
+        size.times do
+          element = read_field(iprot, field_info(field[:element]))
+          value << element
+        end
+        iprot.read_set_end
+      else
+        value = iprot.read_type(field[:type])
+      end
+      value
+    end
+
+    def write_data(oprot, value, field)
+      if is_container? field[:type]
+        write_container(oprot, value, field)
+      else
+        oprot.write_type(field[:type], value)
+      end
+    end
+
+    def write_container(oprot, value, field = {})
+      case field[:type]
+      when Types::MAP
+        oprot.write_map_begin(field[:key][:type], field[:value][:type], value.size)
+        value.each do |k, v|
+          write_data(oprot, k, field[:key])
+          write_data(oprot, v, field[:value])
+        end
+        oprot.write_map_end
+      when Types::LIST
+        oprot.write_list_begin(field[:element][:type], value.size)
+        value.each do |elem|
+          write_data(oprot, elem, field[:element])
+        end
+        oprot.write_list_end
+      when Types::SET
+        oprot.write_set_begin(field[:element][:type], value.size)
+        value.each do |v,| # the , is to preserve compatibility with the old Hash-style sets
+          write_data(oprot, v, field[:element])
+        end
+        oprot.write_set_end
+      else
+        raise "Not a container type: #{field[:type]}"
+      end
+    end
+
+    def is_container?(type)
+      [Types::LIST, Types::MAP, Types::SET].include? type
+    end
+
+    def field_info(field)
+      { :type => field[:type],
+        :class => field[:class],
+        :key => field[:key],
+        :value => field[:value],
+        :element => field[:element] }
+    end
+  end
+  deprecate_module! :ThriftStruct => Struct
+end

data/lib/thrift/thrift.rb

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

@@ -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/lib/thrift/transport/socket.rb

@@ -0,0 +1,167 @@
+# 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
+        addrinfo = ::Socket::getaddrinfo(@host, @port).first
+        @handle = ::Socket.new(addrinfo[4], ::Socket::SOCK_STREAM, 0)
+        sockaddr = ::Socket.sockaddr_in(addrinfo[1], addrinfo[3])
+        begin
+          @handle.connect_nonblock(sockaddr)
+        rescue Errno::EINPROGRESS
+          unless IO.select(nil, [ @handle ], nil, @timeout)
+            raise TransportException.new(TransportException::NOT_OPEN, "Connection timeout to #{@desc}")
+          end
+          begin
+            @handle.connect_nonblock(sockaddr)
+          rescue Errno::EISCONN
+          end
+        end
+        @handle
+      rescue StandardError => e
+        raise TransportException.new(TransportException::NOT_OPEN, "Could not connect to #{@desc}: #{e}")
+      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/lib/thrift/transport/thttpclient.rb

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

data/lib/thrift/transport/tsocket.rb

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

data/lib/thrift/transport/ttransport.rb

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

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