thrift 0.24.0 → 0.25.0

data/lib/thrift/server/nonblocking_server.rb

@@ -18,15 +18,20 @@
 # under the License.
 #
 
-require 'logger'
-require 'thread'
+require "logger"
+require "thread"
 
 module Thrift
   # this class expects to always use a FramedTransport for reading messages
   class NonblockingServer < BaseServer
-    def initialize(processor, server_transport, transport_factory = nil, protocol_factory = nil, num = 20, logger = nil)
+    def initialize(processor, server_transport, transport_factory = nil, protocol_factory = nil, num = 20, logger = nil,
+                   max_frame_size: FramedTransport::DEFAULT_MAX_FRAME_SIZE)
       super(processor, server_transport, transport_factory, protocol_factory)
+      unless max_frame_size > 0 && max_frame_size <= FramedTransport::HARD_MAX_FRAME_SIZE
+        raise ArgumentError, "max_frame_size must be > 0 and <= #{FramedTransport::HARD_MAX_FRAME_SIZE}"
+      end
       @num_threads = num
+      @max_frame_size = max_frame_size
       if logger.nil?
         @logger = Logger.new(STDERR)
         @logger.level = Logger::WARN
@@ -53,11 +58,16 @@ module Thrift
             break
           end
           next if rd.nil?
-          socket = @server_transport.accept
+          begin
+            socket = @server_transport.accept
+          rescue => e
+            next if defined?(OpenSSL::SSL::SSLError) && e.is_a?(OpenSSL::SSL::SSLError)
+            raise
+          end
           @logger.debug "Accepted socket: #{socket.inspect}"
           @io_manager.add_connection socket
         end
-      rescue IOError => e
+      rescue IOError
       end
       # we must be shutting down
       @logger.info "#{self} is shutting down, goodbye"
@@ -84,14 +94,17 @@ module Thrift
       if block
         shutdown_proc.call
       else
-        Thread.new &shutdown_proc
+        Thread.new(&shutdown_proc)
       end
     end
 
     private
 
     def start_io_manager
-      iom = IOManager.new(@processor, @server_transport, @transport_factory, @protocol_factory, @num_threads, @logger)
+      iom = IOManager.new(
+        @processor, @server_transport, @transport_factory, @protocol_factory, @num_threads, @logger,
+        max_frame_size: @max_frame_size,
+      )
       iom.spawn
       iom
     end
@@ -99,13 +112,15 @@ module Thrift
     class IOManager # :nodoc:
       DEFAULT_BUFFER = 2**20
 
-      def initialize(processor, server_transport, transport_factory, protocol_factory, num, logger)
+      def initialize(processor, server_transport, transport_factory, protocol_factory, num, logger,
+                     max_frame_size: FramedTransport::DEFAULT_MAX_FRAME_SIZE)
         @processor = processor
         @server_transport = server_transport
         @transport_factory = transport_factory
         @protocol_factory = protocol_factory
         @num_threads = num
         @logger = logger
+        @max_frame_size = max_frame_size
         @connections = []
         @buffers = Hash.new { |h, k| h[k] = Bytes.empty_byte_buffer }
         @signal_queue = Queue.new
@@ -158,15 +173,13 @@ module Thrift
             break if read_signals == :shutdown
           end
           rd.each do |fd|
-            begin
-              if fd.handle.eof?
-                remove_connection fd
-              else
-                read_connection fd
-              end
-            rescue Errno::ECONNRESET
+            if fd.handle.eof?
               remove_connection fd
+            else
+              read_connection fd
             end
+          rescue Errno::ECONNRESET
+            remove_connection fd
           end
         end
         join_worker_threads(@shutdown_timeout)
@@ -175,8 +188,22 @@ module Thrift
       end
 
       def read_connection(fd)
-        @buffers[fd] << fd.read(DEFAULT_BUFFER)
-        while(frame = slice_frame!(@buffers[fd]))
+        buf = @buffers[fd]
+        buf << fd.read(DEFAULT_BUFFER)
+        while buf.length >= 4
+          # Refuse the size before collecting the frame: the four-byte length
+          # is read here and the bytes are then buffered as they arrive, for as
+          # long as the declared length allows. FramedTransport applies the
+          # same maximum to the frame the worker later reads back.
+          size = buf.unpack1("N")
+          if size > @max_frame_size
+            @logger.error "Frame size #{size} exceeds maximum #{@max_frame_size}, closing connection"
+            fd.close
+            remove_connection fd
+            break
+          end
+          frame = slice_frame!(buf)
+          break if frame.nil?
           @logger.debug "#{self} is processing a frame"
           @worker_queue.push [:frame, fd, frame]
         end
@@ -254,10 +281,8 @@ module Thrift
 
       def close_connections
         @connections.each do |fd|
-          begin
-            fd.close
-          rescue IOError, SystemCallError, TransportException
-          end
+          fd.close
+        rescue IOError, SystemCallError, TransportException
         end
         @connections.clear
         @buffers.clear
@@ -265,16 +290,14 @@ module Thrift
 
       def close_signal_pipes
         @signal_pipes.each do |pipe|
-          begin
-            pipe.close unless pipe.closed?
-          rescue IOError
-          end
+          pipe.close unless pipe.closed?
+        rescue IOError
         end
       end
 
       def slice_frame!(buf)
         if buf.length >= 4
-          size = buf.unpack('N').first
+          size = buf.unpack1("N")
           if buf.length >= size + 4
             buf.slice!(0, size + 4)
           else

data/lib/thrift/server/rack_application.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+require "rack"
+require "thrift/transport/io_stream_transport"
+
+module Thrift
+  class RackApplication
+    THRIFT_HEADER = "application/x-thrift"
+
+    def initialize(processor, protocol_factory = BinaryProtocolFactory.new)
+      @processor = processor
+      @protocol_factory = protocol_factory
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      if self.class.valid_thrift_request?(request)
+        self.class.successful_request(request, @processor, @protocol_factory).finish
+      else
+        self.class.failed_request.finish
+      end
+    end
+
+    def self.mapped(path, processor, protocol_factory = BinaryProtocolFactory.new)
+      Rack::Builder.new do
+        use Rack::ContentLength
+        map path do
+          run RackApplication.new(processor, protocol_factory)
+        end
+      end
+    end
+
+    def self.successful_request(rack_request, processor, protocol_factory)
+      response = Rack::Response.new([], 200, {Rack::CONTENT_TYPE => THRIFT_HEADER})
+      transport = IOStreamTransport.new(rack_request.body, response)
+      protocol = protocol_factory.get_protocol(transport)
+      processor.process protocol, protocol
+
+      response
+    end
+
+    def self.failed_request
+      Rack::Response.new(["Not Found"], 404, {Rack::CONTENT_TYPE => THRIFT_HEADER})
+    end
+
+    def self.valid_thrift_request?(rack_request)
+      rack_request.post? && rack_request.media_type == THRIFT_HEADER
+    end
+  end
+end

data/lib/thrift/server/simple_server.rb

@@ -21,35 +21,39 @@
 module Thrift
   class SimpleServer < BaseServer
     def serve
-      begin
-        @server_transport.listen
-        loop do
-          begin
-            client = @server_transport.accept
-          rescue Errno::ECONNRESET, Errno::EPIPE
-            next
-          rescue => e
-            next if defined?(OpenSSL::SSL::SSLError) && e.is_a?(OpenSSL::SSL::SSLError)
-            raise
-          end
-          trans = @transport_factory.get_transport(client)
-          prot = @protocol_factory.get_protocol(trans)
-          begin
-            loop do
-              @processor.process(prot, prot)
-            end
-          rescue Thrift::TransportException, Thrift::ProtocolException
-          ensure
-            trans.close
+      @server_transport.listen
+      loop do
+        begin
+          client = @server_transport.accept
+        rescue Errno::ECONNRESET, Errno::EPIPE
+          next
+        rescue => e
+          next if defined?(OpenSSL::SSL::SSLError) && e.is_a?(OpenSSL::SSL::SSLError)
+          raise
+        end
+        trans = @transport_factory.get_transport(client)
+        prot = @protocol_factory.get_protocol(trans)
+        begin
+          loop do
+            @processor.process(prot, prot)
           end
+        rescue Thrift::TransportException, Thrift::ProtocolException
+          # The client hung up or sent a message this connection could not
+          # read. Close it below and keep accepting other clients.
+        rescue => e
+          # Any other error raised while serving this one client must not end
+          # the accept loop. Log it, close the connection, and keep serving.
+          @logger.error("Error while serving a client connection: #{e.inspect}")
+        ensure
+          trans.close
         end
-      ensure
-        @server_transport.close
       end
+    ensure
+      @server_transport.close
     end
 
     def to_s
-      "simple(#{super.to_s})"
+      "simple(#{super})"
     end
   end
 end

data/lib/thrift/server/thin_http_server.rb

@@ -18,14 +18,16 @@
 # under the License.
 #
 
-require 'rack'
-require 'thin'
+require "rack"
+require "thin"
+require "thrift/server/rack_application"
 
 ##
 # Wraps the Thin web server to provide a Thrift server over HTTP.
+# <b>DEPRECATED:</b> Use <tt>Thrift::RackApplication</tt> with a maintained Rack
+# server instead.
 module Thrift
   class ThinHTTPServer < BaseServer
-
     ##
     # Accepts a Thrift::Processor
     # Options include:
@@ -33,13 +35,26 @@ module Thrift
     # * :ip
     # * :path
     # * :protocol_factory
+    # * :ssl
+    # * :ssl_options
     def initialize(processor, options = {})
+      Kernel.warn "[DEPRECATION WARNING] `Thrift::ThinHTTPServer` is deprecated because Thin is no longer maintained. Please use `Thrift::RackApplication` with a maintained Rack server instead."
       port = options[:port] || 80
       ip = options[:ip] || "0.0.0.0"
       path = options[:path] || "/"
       protocol_factory = options[:protocol_factory] || BinaryProtocolFactory.new
-      app = RackApplication.for(path, processor, protocol_factory)
+      endpoint = RackApplication.mapped(path, processor, protocol_factory)
+      app = Rack::Builder.new do
+        use Rack::CommonLogger
+        use Rack::ShowExceptions
+        use Rack::Lint
+        run endpoint
+      end
       @server = Thin::Server.new(ip, port, app)
+      if options[:ssl]
+        @server.ssl = true
+        @server.ssl_options = options[:ssl_options] || {}
+      end
     end
 
     ##
@@ -48,45 +63,6 @@ module Thrift
       @server.start
     end
 
-    class RackApplication
-
-      THRIFT_HEADER = "application/x-thrift"
-
-      def self.for(path, processor, protocol_factory)
-        Rack::Builder.new do
-          use Rack::CommonLogger
-          use Rack::ShowExceptions
-          use Rack::Lint
-          map path do
-            run lambda { |env|
-              request = Rack::Request.new(env)
-              if RackApplication.valid_thrift_request?(request)
-                RackApplication.successful_request(request, processor, protocol_factory).finish
-              else
-                RackApplication.failed_request.finish
-              end
-            }
-          end
-        end
-      end
-
-      def self.successful_request(rack_request, processor, protocol_factory)
-        response = Rack::Response.new([], 200, {'Content-Type' => THRIFT_HEADER})
-        transport = IOStreamTransport.new rack_request.body, response
-        protocol = protocol_factory.get_protocol transport
-        processor.process protocol, protocol
-        response
-      end
-
-      def self.failed_request
-        Rack::Response.new(['Not Found'], 404, {'Content-Type' => THRIFT_HEADER})
-      end
-
-      def self.valid_thrift_request?(rack_request)
-        rack_request.post? && rack_request.env["CONTENT_TYPE"] == THRIFT_HEADER
-      end
-
-    end
-
+    RackApplication = Thrift::RackApplication
   end
 end

data/lib/thrift/server/thread_pool_server.rb

@@ -18,7 +18,7 @@
 # under the License.
 #
 
-require 'thread'
+require "thread"
 
 module Thrift
   class ThreadPoolServer < BaseServer
@@ -47,25 +47,28 @@ module Thrift
         loop do
           @thread_q.push(:token)
           Thread.new do
-            begin
-              loop do
+            loop do
+              begin
                 client = @server_transport.accept
-                trans = @transport_factory.get_transport(client)
-                prot = @protocol_factory.get_protocol(trans)
-                begin
-                  loop do
-                    @processor.process(prot, prot)
-                  end
-                rescue Thrift::TransportException, Thrift::ProtocolException => e
-                ensure
-                  trans.close
+              rescue => e
+                next if defined?(OpenSSL::SSL::SSLError) && e.is_a?(OpenSSL::SSL::SSLError)
+                raise
+              end
+              trans = @transport_factory.get_transport(client)
+              prot = @protocol_factory.get_protocol(trans)
+              begin
+                loop do
+                  @processor.process(prot, prot)
                 end
+              rescue Thrift::TransportException, Thrift::ProtocolException
+              ensure
+                trans.close
               end
-            rescue => e
-              @exception_q.push(e)
-            ensure
-              @thread_q.pop # thread died!
             end
+          rescue => e
+            @exception_q.push(e)
+          ensure
+            @thread_q.pop # thread died!
           end
         end
       ensure
@@ -74,7 +77,7 @@ module Thrift
     end
 
     def to_s
-      "threadpool(#{super.to_s})"
+      "threadpool(#{super})"
     end
   end
 end

data/lib/thrift/server/threaded_server.rb

@@ -18,42 +18,38 @@
 # under the License.
 #
 
-require 'thread'
+require "thread"
 
 module Thrift
   class ThreadedServer < BaseServer
     def serve
-      begin
-        @server_transport.listen
-        loop do
-          begin
-            client = @server_transport.accept
-          rescue Errno::ECONNRESET, Errno::EPIPE
-            next
-          rescue => e
-            next if defined?(OpenSSL::SSL::SSLError) && e.is_a?(OpenSSL::SSL::SSLError)
-            raise
-          end
-          trans = @transport_factory.get_transport(client)
-          prot = @protocol_factory.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
+      @server_transport.listen
+      loop do
+        begin
+          client = @server_transport.accept
+        rescue Errno::ECONNRESET, Errno::EPIPE
+          next
+        rescue => e
+          next if defined?(OpenSSL::SSL::SSLError) && e.is_a?(OpenSSL::SSL::SSLError)
+          raise
+        end
+        trans = @transport_factory.get_transport(client)
+        prot = @protocol_factory.get_protocol(trans)
+        Thread.new(prot, trans) do |p, t|
+          loop do
+            @processor.process(p, p)
           end
+        rescue Thrift::TransportException, Thrift::ProtocolException
+        ensure
+          t.close
         end
-      ensure
-        @server_transport.close
       end
+    ensure
+      @server_transport.close
     end
 
     def to_s
-      "threaded(#{super.to_s})"
+      "threaded(#{super})"
     end
   end
 end

data/lib/thrift/struct.rb

@@ -18,7 +18,8 @@
 # under the License.
 #
 
-require 'set'
+require "set"
+require "thrift/struct_union"
 
 module Thrift
   module Struct
@@ -52,7 +53,7 @@ module Thrift
         end
       end
 
-      yield self if block_given?
+      yield self if block
     end
 
     def fields_with_default_values
@@ -81,19 +82,31 @@ module Thrift
       "<#{self.class} #{fields.join(", ")}>"
     end
 
-    def read(iprot)
+    def read(iprot, remaining_depth = DEFAULT_RECURSION_DEPTH)
+      raise ProtocolException.new(ProtocolException::DEPTH_LIMIT, "Maximum recursion depth exceeded") if remaining_depth <= 0
+      unless instance_variables.empty?
+        defaults = fields_with_default_values
+        struct_fields.each_value do |field_info|
+          instance_variable_set("@#{field_info[:name]}", nil)
+        end
+        defaults.each do |name, default_value|
+          instance_variable_set("@#{name}", (default_value.dup rescue default_value))
+        end
+      end
+
       iprot.read_struct_begin
       loop do
-        fname, ftype, fid = iprot.read_field_begin
+        _, ftype, fid = iprot.read_field_begin
         break if (ftype == Types::STOP)
-        handle_message(iprot, fid, ftype)
+        handle_message(iprot, fid, ftype, remaining_depth)
         iprot.read_field_end
       end
       iprot.read_struct_end
       validate
     end
 
-    def write(oprot)
+    def write(oprot, remaining_depth = DEFAULT_RECURSION_DEPTH)
+      raise ProtocolException.new(ProtocolException::DEPTH_LIMIT, "Maximum recursion depth exceeded") if remaining_depth <= 0
       validate
       oprot.write_struct_begin(self.class.name)
       each_field do |fid, field_info|
@@ -103,8 +116,10 @@ module Thrift
         unless value.nil?
           if is_container? type
             oprot.write_field_begin(name, type, fid)
-            write_container(oprot, value, field_info)
+            write_container(oprot, value, field_info, remaining_depth)
             oprot.write_field_end
+          elsif type == Types::STRUCT
+            oprot.write_field(field_info, fid, value, remaining_depth)
           else
             oprot.write_field(field_info, fid, value)
           end
@@ -115,10 +130,10 @@ module Thrift
     end
 
     def ==(other)
-      return false if other.nil?
+      return false unless other.instance_of?(self.class)
       each_field do |fid, field_info|
         name = field_info[:name]
-        return false unless other.respond_to?(name) && self.send(name) == other.send(name)
+        return false unless other.respond_to?(name) && send(name) == other.send(name)
       end
       true
     end
@@ -132,8 +147,8 @@ module Thrift
       total = 17
       each_field do |fid, field_info|
         name = field_info[:name]
-        value = self.send(name)
-        total = (total * 37 + value.hash) & 0xffffffff
+        value = send(name)
+        total = ((total * 37) + value.hash) & 0xffffffff
       end
       total
     end
@@ -145,7 +160,7 @@ module Thrift
       else
         each_field do |fid, field_info|
           name = field_info[:name]
-          diffs << "#{name} differs!" unless self.instance_variable_get("@#{name}") == other.instance_variable_get("@#{name}")
+          diffs << "#{name} differs!" unless instance_variable_get("@#{name}") == other.instance_variable_get("@#{name}")
         end
       end
       diffs
@@ -169,14 +184,14 @@ module Thrift
 
     def self.qmark_isset_method(klass, field_info)
       klass.send :define_method, "#{field_info[:name]}?" do
-        !self.send(field_info[:name].to_sym).nil?
+        !send(field_info[:name].to_sym).nil?
       end
     end
 
     def <=>(other)
       if self.class == other.class
         each_field do |fid, field_info|
-          v1 = self.send(field_info[:name])
+          v1 = send(field_info[:name])
           v1_set = !v1.nil?
           v2 = other.send(field_info[:name])
           v2_set = !v2.nil?
@@ -218,17 +233,17 @@ module Thrift
       else
         # call the Struct initializer first with no args
         # this will set our field default values
-        method(:struct_initialize).call()
+        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.send(:class_variable_get, :'@@__thrift_struct_real_initialize').bind_call(self, *args, &block) if args.size > 0
         # self.class.instance_method(:initialize).bind(self).call(*args, &block)
       end
     end
 
-    def handle_message(iprot, fid, ftype)
+    def handle_message(iprot, fid, ftype, remaining_depth)
       field = struct_fields[fid]
       if field and field[:type] == ftype
-        value = read_field(iprot, field)
+        value = read_field(iprot, field, remaining_depth)
         instance_variable_set("@#{field[:name]}", value)
       else
         iprot.skip(ftype)