thrift 0.23.0 → 0.24.0

data/spec/multiplexed_processor_spec.rb

@@ -0,0 +1,75 @@
+# 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 'spec_helper'
+
+describe Thrift::MultiplexedProcessor do
+  before(:each) do
+    @processor = Thrift::MultiplexedProcessor.new
+    @iprot = double('MockInputProtocol')
+    @oprot = double('MockOutputProtocol')
+  end
+
+  it 'dispatches multiplexed calls to the registered service processor' do
+    actual_processor = double('ActualProcessor')
+    @processor.register_processor('ThriftTest', actual_processor)
+
+    expect(@iprot).to receive(:read_message_begin).and_return(['ThriftTest:testVoid', Thrift::MessageTypes::CALL, 1])
+    expect(actual_processor).to receive(:process) do |stored_protocol, oprot|
+      expect(stored_protocol.read_message_begin).to eq(['testVoid', Thrift::MessageTypes::CALL, 1])
+      expect(oprot).to eq(@oprot)
+      true
+    end
+
+    expect(@processor.process(@iprot, @oprot)).to eq(true)
+  end
+
+  it 'dispatches non-multiplexed calls to the default processor' do
+    default_processor = double('DefaultProcessor')
+    @processor.register_default(default_processor)
+
+    expect(@iprot).to receive(:read_message_begin).and_return(['testVoid', Thrift::MessageTypes::CALL, 2])
+    expect(default_processor).to receive(:process) do |stored_protocol, oprot|
+      expect(stored_protocol.read_message_begin).to eq(['testVoid', Thrift::MessageTypes::CALL, 2])
+      expect(oprot).to eq(@oprot)
+      true
+    end
+
+    expect(@processor.process(@iprot, @oprot)).to eq(true)
+  end
+
+  it 'raises for non-multiplexed calls when no default processor is registered' do
+    expect(@iprot).to receive(:read_message_begin).and_return(['testVoid', Thrift::MessageTypes::CALL, 3])
+
+    expect { @processor.process(@iprot, @oprot) }.to raise_error(
+      Thrift::Exception,
+      'Service name not found in message name: testVoid. Did you forget to use a Thrift::Protocol::MultiplexedProtocol in your client?'
+    )
+  end
+
+  it 'raises for unknown multiplexed service names' do
+    expect(@iprot).to receive(:read_message_begin).and_return(['Missing:testVoid', Thrift::MessageTypes::CALL, 4])
+
+    expect { @processor.process(@iprot, @oprot) }.to raise_error(
+      Thrift::Exception,
+      'Service name not found: Missing. Did you forget to call Thrift::MultiplexedProcessor#register_processor?'
+    )
+  end
+end

data/spec/namespaced_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file

data/spec/nonblocking_server_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -101,7 +102,7 @@ describe 'NonblockingServer' do
 
   describe Thrift::NonblockingServer do
     before(:each) do
-      @port = 43251
+      @port = available_port
       handler = Handler.new
       processor = SpecNamespace::NonblockingService::Processor.new(handler)
       queue = Queue.new
@@ -121,6 +122,7 @@ describe 'NonblockingServer' do
         end
       end
       queue.pop
+      wait_until_listening(@transport, @server_thread)
 
       @clients = []
       @catch_exceptions = false
@@ -128,9 +130,11 @@ describe 'NonblockingServer' do
 
     after(:each) do
       @clients.each { |client, trans| trans.close }
-      # @server.shutdown(1)
-      @server_thread.kill
-      @transport.close
+      @server.shutdown(1, false) if @server
+      @server_thread.join(2) if @server_thread
+      @server_thread.kill if @server_thread && @server_thread.alive?
+      @server_thread.join(2) if @server_thread
+      @transport.close if @transport
     end
 
     def setup_client(queue = nil)
@@ -261,6 +265,70 @@ describe 'NonblockingServer' do
     end
   end
 
+  describe Thrift::NonblockingServer::IOManager do
+    def build_io_manager
+      logger = Logger.new(IO::NULL)
+      logger.level = Logger::FATAL
+      Thrift::NonblockingServer::IOManager.new(
+        double('processor'),
+        double('server_transport'),
+        Thrift::BaseTransportFactory.new,
+        Thrift::BinaryProtocolFactory.new,
+        1,
+        logger
+      )
+    end
+
+    it "closes tracked connections and signal pipes during forced cleanup" do
+      io_manager = build_io_manager
+      connection = double('connection', :close => nil)
+      pipe_a = double('pipe_a', :closed? => false, :close => nil)
+      pipe_b = double('pipe_b', :closed? => false, :close => nil)
+
+      io_manager.instance_variable_set(:@connections, [connection])
+      io_manager.instance_variable_set(:@buffers, { connection => 'frame' })
+      io_manager.instance_variable_set(:@signal_pipes, [pipe_a, pipe_b])
+      io_manager.instance_variable_set(:@worker_threads, [])
+
+      io_manager.ensure_closed
+
+      expect(connection).to have_received(:close)
+      expect(pipe_a).to have_received(:close)
+      expect(pipe_b).to have_received(:close)
+      expect(io_manager.instance_variable_get(:@connections)).to be_empty
+      expect(io_manager.instance_variable_get(:@buffers)).to be_empty
+    end
+
+    it "continues closing remaining signal pipes when one close raises" do
+      io_manager = build_io_manager
+      pipe_a = double('pipe_a', :closed? => false)
+      pipe_b = double('pipe_b', :closed? => false, :close => nil)
+
+      allow(pipe_a).to receive(:close).and_raise(IOError)
+
+      io_manager.instance_variable_set(:@signal_pipes, [pipe_a, pipe_b])
+      io_manager.instance_variable_set(:@worker_threads, [])
+
+      io_manager.send(:close_signal_pipes)
+
+      expect(pipe_a).to have_received(:close)
+      expect(pipe_b).to have_received(:close)
+    end
+
+    it "drops removed connections from bookkeeping" do
+      io_manager = build_io_manager
+      connection = double('connection', :close => nil)
+
+      io_manager.instance_variable_set(:@connections, [connection])
+      io_manager.instance_variable_set(:@buffers, { connection => 'frame' })
+
+      io_manager.send(:remove_connection, connection)
+
+      expect(io_manager.instance_variable_get(:@connections)).to be_empty
+      expect(io_manager.instance_variable_get(:@buffers)).to be_empty
+    end
+  end
+
   describe "#{Thrift::NonblockingServer} with TLS transport" do
     before(:each) do
       @port = available_port
@@ -282,7 +350,7 @@ describe 'NonblockingServer' do
       end
 
       @clients = []
-      wait_until_listening
+      wait_until_listening(@transport, @server_thread)
     end
 
     after(:each) do
@@ -313,19 +381,6 @@ describe 'NonblockingServer' do
       client
     end
 
-    def wait_until_listening
-      Timeout.timeout(2) do
-        until @transport.handle
-          raise "Server thread exited unexpectedly" unless @server_thread.alive?
-          sleep 0.01
-        end
-      end
-    end
-
-    def available_port
-      TCPServer.open('localhost', 0) { |server| server.addr[1] }
-    end
-
     def ssl_keys_dir
       File.expand_path('../../../test/keys', __dir__)
     end
@@ -358,4 +413,17 @@ describe 'NonblockingServer' do
       end
     end
   end
+
+  def wait_until_listening(server_transport, server_thread)
+    Timeout.timeout(2) do
+      until server_transport.handle
+        raise "Server thread exited unexpectedly" unless server_thread.alive?
+        sleep 0.01
+      end
+    end
+  end
+
+  def available_port
+    TCPServer.open('localhost', 0) { |server| server.addr[1] }
+  end
 end

data/spec/processor_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file

data/spec/recursion_depth_spec.rb

@@ -0,0 +1,223 @@
+# 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 'spec_helper'
+
+# Round-trip test for struct/union/exception recursion depth, driving the
+# *generated* read/write path (Thrift::Struct#read/#write,
+# Thrift::Union#read/#write) over RecTree / RecUnion / RecError from
+# ThriftSpec.thrift; a linear chain is one struct level deeper per node, so a
+# chain of N nodes reaches depth N.
+#
+# NOTE: the Ruby library does not enforce a recursion-depth limit yet
+# (THRIFT-6045). The round-trip / within-limit examples are active; the
+# limit-enforcement (over-limit) examples are `pending` and will start passing
+# once the limit is implemented, at which point RSpec flags them to be enabled.
+describe 'recursion depth limit' do
+  # The intended struct/union nesting limit. The Ruby library does not enforce a
+  # recursion-depth limit yet (THRIFT-6045); the limit-enforcement examples below
+  # are therefore `pending` until it is implemented. 64 matches the limit other
+  # Thrift libraries use.
+  RECURSION_LIMIT = 64
+
+  # Attached to the pending (over-limit) examples.
+  PENDING_REASON = 'recursion-depth limit not implemented in the Ruby library yet (THRIFT-6045)'
+
+  def binary_protocol
+    Thrift::BinaryProtocol.new(Thrift::MemoryBufferTransport.new)
+  end
+
+  # A linearly nested RecTree that is `depth` struct levels deep.
+  def struct_chain(depth)
+    node = SpecNamespace::RecTree.new(item: depth, children: [])
+    node.children = [struct_chain(depth - 1)] if depth > 1
+    node
+  end
+
+  def tree_depth(node)
+    n = 0
+    until node.nil?
+      n += 1
+      break if node.children.nil? || node.children.empty?
+      node = node.children.first
+    end
+    n
+  end
+
+  # A linearly nested RecUnion that is `depth` levels deep (each union holds the
+  # next; the innermost holds a scalar leaf).
+  def union_chain(depth)
+    if depth > 1
+      SpecNamespace::RecUnion.new(children: [union_chain(depth - 1)])
+    else
+      SpecNamespace::RecUnion.new(leaf: 0)
+    end
+  end
+
+  # A linearly nested RecError exception that is `depth` struct levels deep.
+  # Exceptions read/write through the same generated path as structs, so
+  # tree_depth applies to the decoded chain too.
+  def error_chain(depth)
+    node = SpecNamespace::RecError.new(leaf: depth, children: [])
+    node.children = [error_chain(depth - 1)] if depth > 1
+    node
+  end
+
+  # Emit, via raw protocol calls (which carry no depth guard), the wire image of
+  # a RecTree chain `depth` levels deep. This lets the read tests feed an
+  # over-limit payload that the guarded writer would itself refuse to produce.
+  def write_raw_tree(oprot, depth)
+    oprot.write_struct_begin('RecTree')
+    oprot.write_field_begin('children', Thrift::Types::LIST, 1)
+    oprot.write_list_begin(Thrift::Types::STRUCT, depth > 1 ? 1 : 0)
+    write_raw_tree(oprot, depth - 1) if depth > 1
+    oprot.write_list_end
+    oprot.write_field_end
+    oprot.write_field_begin('item', Thrift::Types::I16, 2)
+    oprot.write_i16(depth)
+    oprot.write_field_end
+    oprot.write_field_stop
+    oprot.write_struct_end
+  end
+
+  # Same as write_raw_tree but for the RecError exception (leaf is i32 here).
+  def write_raw_error(oprot, depth)
+    oprot.write_struct_begin('RecError')
+    oprot.write_field_begin('children', Thrift::Types::LIST, 1)
+    oprot.write_list_begin(Thrift::Types::STRUCT, depth > 1 ? 1 : 0)
+    write_raw_error(oprot, depth - 1) if depth > 1
+    oprot.write_list_end
+    oprot.write_field_end
+    oprot.write_field_begin('leaf', Thrift::Types::I32, 2)
+    oprot.write_i32(depth)
+    oprot.write_field_end
+    oprot.write_field_stop
+    oprot.write_struct_end
+  end
+
+  def expect_depth_limit
+    expect { yield }.to raise_error(Thrift::ProtocolException) { |e|
+      expect(e.type).to eq(Thrift::ProtocolException::DEPTH_LIMIT)
+    }
+  end
+
+  describe 'structs' do
+    it 'round-trips a chain at the limit' do
+      prot = binary_protocol
+      struct_chain(RECURSION_LIMIT).write(prot)
+      result = SpecNamespace::RecTree.new
+      result.read(prot)
+      expect(tree_depth(result)).to eq(RECURSION_LIMIT)
+    end
+
+    it 'rejects writing a chain past the limit' do
+      pending PENDING_REASON
+      expect_depth_limit { struct_chain(RECURSION_LIMIT + 1).write(binary_protocol) }
+    end
+
+    it 'rejects reading a payload past the limit' do
+      pending PENDING_REASON
+      prot = binary_protocol
+      write_raw_tree(prot, RECURSION_LIMIT + 1)
+      expect_depth_limit { SpecNamespace::RecTree.new.read(prot) }
+    end
+
+    it 'round-trips a wide shallow tree (counter unwinds per sibling)' do
+      width = RECURSION_LIMIT * 3
+      prot = binary_protocol
+      root = SpecNamespace::RecTree.new(
+        item: 0,
+        children: (1..width).map { |i| SpecNamespace::RecTree.new(item: i, children: []) }
+      )
+      root.write(prot)
+      result = SpecNamespace::RecTree.new
+      result.read(prot)
+      expect(result.children.size).to eq(width)
+    end
+  end
+
+  describe 'unions' do
+    it 'round-trips a chain at the limit' do
+      prot = binary_protocol
+      union_chain(RECURSION_LIMIT).write(prot)
+      expect { SpecNamespace::RecUnion.new.read(prot) }.not_to raise_error
+    end
+
+    it 'rejects writing a chain past the limit' do
+      pending PENDING_REASON
+      expect_depth_limit { union_chain(RECURSION_LIMIT + 1).write(binary_protocol) }
+    end
+  end
+
+  describe 'exceptions' do
+    it 'round-trips a chain at the limit' do
+      prot = binary_protocol
+      error_chain(RECURSION_LIMIT).write(prot)
+      result = SpecNamespace::RecError.new
+      result.read(prot)
+      expect(tree_depth(result)).to eq(RECURSION_LIMIT)
+    end
+
+    it 'rejects writing a chain past the limit' do
+      pending PENDING_REASON
+      expect_depth_limit { error_chain(RECURSION_LIMIT + 1).write(binary_protocol) }
+    end
+
+    it 'rejects reading a payload past the limit' do
+      pending PENDING_REASON
+      prot = binary_protocol
+      write_raw_error(prot, RECURSION_LIMIT + 1)
+      expect_depth_limit { SpecNamespace::RecError.new.read(prot) }
+    end
+  end
+
+  describe 'protocol decorators' do
+    # A struct written through a decorator must still be bounded and must not
+    # crash: decorators (MultiplexedProtocol via ProtocolDecorator) do not chain
+    # BaseProtocol#initialize, so the depth counter starts unset on that object.
+    it 'round-trips a struct through a MultiplexedProtocol' do
+      mprot = Thrift::MultiplexedProtocol.new(binary_protocol, 'svc')
+      struct_chain(3).write(mprot)
+      result = SpecNamespace::RecTree.new
+      result.read(mprot)
+      expect(tree_depth(result)).to eq(3)
+    end
+  end
+
+  # Only present when the native (thrift_native) extension is loaded, which
+  # also makes Thrift::Struct#read/#write the native implementations -- the path
+  # that must enforce the limit in C, not just in pure Ruby.
+  if defined? Thrift::BinaryProtocolAccelerated
+    describe 'accelerated binary protocol' do
+      it 'rejects writing a chain past the limit' do
+        pending PENDING_REASON
+        prot = Thrift::BinaryProtocolAccelerated.new(Thrift::MemoryBufferTransport.new)
+        expect_depth_limit { struct_chain(RECURSION_LIMIT + 1).write(prot) }
+      end
+
+      it 'rejects reading a payload past the limit' do
+        pending PENDING_REASON
+        prot = Thrift::BinaryProtocolAccelerated.new(Thrift::MemoryBufferTransport.new)
+        write_raw_tree(prot, RECURSION_LIMIT + 1)
+        expect_depth_limit { SpecNamespace::RecTree.new.read(prot) }
+      end
+    end
+  end
+end

data/spec/serializer_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file

data/spec/server_socket_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -47,10 +48,46 @@ describe 'Thrift::ServerSocket' do
       expect(handle).to receive(:accept).and_return(sock)
       trans = double("Socket")
       expect(Thrift::Socket).to receive(:new).and_return(trans)
+      expect(trans).to receive(:timeout=).with(Thrift::BaseServerTransport::DEFAULT_CLIENT_TIMEOUT)
       expect(trans).to receive(:handle=).with(sock)
       expect(@socket.accept).to eq(trans)
     end
 
+    it "should default accepted sockets to a finite client timeout" do
+      expect(@socket.client_timeout).to eq(5)
+    end
+
+    it "should accept a custom client timeout" do
+      @socket = Thrift::ServerSocket.new(1234, client_timeout: 2.5)
+      expect(@socket.client_timeout).to eq(2.5)
+    end
+
+    it "should allow blocking accepted sockets with nil or zero client timeout" do
+      expect(Thrift::ServerSocket.new(1234, client_timeout: nil).client_timeout).to be_nil
+      expect(Thrift::ServerSocket.new(1234, client_timeout: 0).client_timeout).to eq(0)
+    end
+
+    it "should use the accepted socket timeout for writes" do
+      handle = double("TCPServer")
+      allow(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)
+      @socket.listen
+
+      sock = double("sock", :closed? => false)
+      allow(sock).to receive(:setsockopt)
+      allow(handle).to receive(:accept).and_return(sock)
+
+      transport = @socket.accept
+      expect(transport.timeout).to eq(Thrift::BaseServerTransport::DEFAULT_CLIENT_TIMEOUT)
+
+      expect(sock).to receive(:write_nonblock).with("test data").and_raise(IO::EAGAINWaitWritable)
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 100.0, 105.1)
+      expect(IO).to receive(:select).with(nil, [sock], nil, 5.0).and_return(nil)
+
+      expect { transport.write("test data") }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+      end
+    end
+
     it "should close the handle when closed" do
       handle = double("TCPServer", :closed? => false)
       expect(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)

data/spec/server_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -17,6 +18,7 @@
 # under the License.
 #
 require 'spec_helper'
+require 'openssl'
 
 describe 'Server' do
   describe Thrift::BaseServer do
@@ -80,6 +82,30 @@ describe 'Server' do
       expect(@serverTrans).to receive(:close).ordered
       expect { @server.serve }.to throw_symbol(:stop)
     end
+
+    it "should continue serving after accept raises Errno::ECONNRESET" do
+      expect(@serverTrans).to receive(:listen).ordered
+      expect(@serverTrans).to receive(:accept).ordered.and_raise(Errno::ECONNRESET)
+      expect(@serverTrans).to receive(:accept).ordered.and_return(@client)
+      expect(@trans).to receive(:get_transport).once.with(@client).and_return(@trans)
+      expect(@prot).to receive(:get_protocol).once.with(@trans).and_return(@prot)
+      expect(@processor).to receive(:process).once.with(@prot, @prot) { throw :stop }
+      expect(@trans).to receive(:close).once
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
+    end
+
+    it "should continue serving after accept raises OpenSSL::SSL::SSLError" do
+      expect(@serverTrans).to receive(:listen).ordered
+      expect(@serverTrans).to receive(:accept).ordered.and_raise(OpenSSL::SSL::SSLError)
+      expect(@serverTrans).to receive(:accept).ordered.and_return(@client)
+      expect(@trans).to receive(:get_transport).once.with(@client).and_return(@trans)
+      expect(@prot).to receive(:get_protocol).once.with(@trans).and_return(@prot)
+      expect(@processor).to receive(:process).once.with(@prot, @prot) { throw :stop }
+      expect(@trans).to receive(:close).once
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
+    end
   end
 
   describe Thrift::ThreadedServer do
@@ -117,6 +143,32 @@ describe 'Server' do
       expect(@serverTrans).to receive(:close).ordered
       expect { @server.serve }.to throw_symbol(:stop)
     end
+
+    it "should continue serving after accept raises Errno::ECONNRESET" do
+      expect(@serverTrans).to receive(:listen).ordered
+      expect(@serverTrans).to receive(:accept).ordered.and_raise(Errno::ECONNRESET)
+      expect(@serverTrans).to receive(:accept).ordered.and_return(@client)
+      expect(@trans).to receive(:get_transport).once.with(@client).and_return(@trans)
+      expect(@prot).to receive(:get_protocol).once.with(@trans).and_return(@prot)
+      expect(Thread).to receive(:new).with(@prot, @trans).once.and_yield(@prot, @trans)
+      expect(@processor).to receive(:process).once.with(@prot, @prot) { throw :stop }
+      expect(@trans).to receive(:close).once
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
+    end
+
+    it "should continue serving after accept raises OpenSSL::SSL::SSLError" do
+      expect(@serverTrans).to receive(:listen).ordered
+      expect(@serverTrans).to receive(:accept).ordered.and_raise(OpenSSL::SSL::SSLError)
+      expect(@serverTrans).to receive(:accept).ordered.and_return(@client)
+      expect(@trans).to receive(:get_transport).once.with(@client).and_return(@trans)
+      expect(@prot).to receive(:get_protocol).once.with(@trans).and_return(@prot)
+      expect(Thread).to receive(:new).with(@prot, @trans).once.and_yield(@prot, @trans)
+      expect(@processor).to receive(:process).once.with(@prot, @prot) { throw :stop }
+      expect(@trans).to receive(:close).once
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
+    end
   end
 
   describe Thrift::ThreadPoolServer do