thrift 0.23.0 → 0.24.0

data/spec/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
@@ -24,44 +25,150 @@ describe 'Socket' do
   describe Thrift::Socket do
     before(:each) do
       @socket = Thrift::Socket.new
+      @addrinfo = double("Addrinfo")
       @handle = double("Handle", :closed? => false)
       allow(@handle).to receive(:close)
-      allow(@handle).to receive(:connect_nonblock)
       allow(@handle).to receive(:setsockopt)
-      allow(::Socket).to receive(:new).and_return(@handle)
+      allow(@addrinfo).to receive(:connect).and_return(@handle)
+      allow(Addrinfo).to receive(:foreach).and_yield(@addrinfo)
     end
 
     it_should_behave_like "a socket"
 
     it "should raise a TransportException when it cannot open a socket" do
-      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
+      allow(Addrinfo).to receive(:foreach).and_raise(SocketError.new("lookup failed"))
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause).to be_a(SocketError)
+      end
     end
 
     it "should open a ::Socket with default args" do
-      expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
-      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect(::Socket).to receive(:sockaddr_in)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo)
+      expect(@addrinfo).to receive(:connect).with(no_args).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
       @socket.to_s == "socket(localhost:9090)"
       @socket.open
     end
 
     it "should accept host/port options" do
-      expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
-      expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect(::Socket).to receive(:sockaddr_in)
+      handle = double("Handle", :closed? => false)
+      allow(handle).to receive(:close)
+      expect(handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(Addrinfo).to receive(:foreach).with("my.domain", 1234, nil, :STREAM).and_yield(@addrinfo)
+      expect(@addrinfo).to receive(:connect).with(no_args).and_return(handle)
       @socket = Thrift::Socket.new('my.domain', 1234).open
       @socket.to_s == "socket(my.domain:1234)"
     end
 
     it "should accept an optional timeout" do
-      allow(::Socket).to receive(:new)
       expect(Thrift::Socket.new('localhost', 8080, 5).timeout).to eq(5)
     end
 
     it "should provide a reasonable to_s" do
-      allow(::Socket).to receive(:new)
       expect(Thrift::Socket.new('myhost', 8090).to_s).to eq("socket(myhost:8090)")
     end
+
+    it "should pass the remaining timeout to each address attempt" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 103.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ECONNREFUSED)
+      expect(second_addrinfo).to receive(:connect).with(timeout: 2.0).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should continue to the next address after a connect timeout while time remains" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 103.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ETIMEDOUT)
+      expect(second_addrinfo).to receive(:connect).with(timeout: 2.0).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should raise TIMED_OUT when an address attempt times out" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ETIMEDOUT)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+        expect(e.message).to eq("Socket: Timed out opening connection to localhost:9090")
+      end
+    end
+
+    it "should raise TIMED_OUT when the deadline expires before the next address attempt" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 105.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ECONNREFUSED)
+      expect(second_addrinfo).not_to receive(:connect)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+        expect(e.message).to eq("Socket: Timed out opening connection to localhost:9090")
+      end
+    end
+
+    it "should treat zero timeout as blocking for open" do
+      @socket.timeout = 0
+
+      expect(@addrinfo).to receive(:connect).with(no_args).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should report the last connection error when all addresses fail" do
+      second_addrinfo = double("Addrinfo")
+
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).and_raise(Errno::ECONNREFUSED)
+      expect(second_addrinfo).to receive(:connect).and_raise(Errno::EHOSTUNREACH)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause).to be_a(Errno::EHOSTUNREACH)
+      end
+    end
+
+    it "should close a connected candidate before falling back when socket setup fails" do
+      first_addrinfo = @addrinfo
+      second_addrinfo = double("Addrinfo")
+      first_handle = double("Handle", :closed? => false)
+      allow(first_handle).to receive(:close)
+
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(first_addrinfo).and_yield(second_addrinfo)
+      expect(first_addrinfo).to receive(:connect).with(no_args).and_return(first_handle)
+      expect(first_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1).and_raise(StandardError.new("setsockopt failed"))
+      expect(first_handle).to receive(:close)
+      expect(second_addrinfo).to receive(:connect).with(no_args).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should avoid a blank error when no addresses are returned" do
+      allow(Addrinfo).to receive(:foreach)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+      end
+    end
   end
 end

data/spec/socket_spec_shared.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/spec_helper.rb

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

data/spec/ssl_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
@@ -38,6 +39,45 @@ describe 'SSLServerSocket' do
       expect(@socket.to_io).to eq(tcp_server)
     end
 
+    it "should default accepted sockets to a finite client timeout" do
+      expect(@socket.client_timeout).to eq(5)
+    end
+
+    it "should preserve the positional ssl context argument" do
+      context = double("SSLContext")
+      socket = Thrift::SSLServerSocket.new(nil, 1234, context)
+
+      expect(socket.ssl_context).to eq(context)
+      expect(socket.client_timeout).to eq(5)
+    end
+
+    it "should accept a custom client timeout" do
+      context = double("SSLContext")
+      socket = Thrift::SSLServerSocket.new(nil, 1234, context, client_timeout: 2.5)
+
+      expect(socket.ssl_context).to eq(context)
+      expect(socket.client_timeout).to eq(2.5)
+    end
+
+    it "should apply the client timeout to accepted sockets" do
+      tcp_server = double("TCPServer")
+      ssl_server = double("SSLServer")
+      sock = double("SSLSocket")
+
+      allow(TCPServer).to receive(:new).with(nil, 1234).and_return(tcp_server)
+      allow(OpenSSL::SSL::SSLServer).to receive(:new).with(tcp_server, nil).and_return(ssl_server)
+      expect(ssl_server).to receive(:accept).and_return(sock)
+      expect(sock).to receive(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+      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)
+
+      @socket.listen
+      expect(@socket.accept).to eq(trans)
+    end
+
     it "should provide a reasonable to_s" do
       expect(@socket.to_s).to eq("ssl(socket(:1234))")
     end

data/spec/ssl_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
@@ -25,40 +26,56 @@ describe 'SSLSocket' do
     before(:each) do
       @context = OpenSSL::SSL::SSLContext.new
       @socket = Thrift::SSLSocket.new
+      @addrinfo = double("Addrinfo")
       @simple_socket_handle = double("Handle", :closed? => false)
       allow(@simple_socket_handle).to receive(:close)
-      allow(@simple_socket_handle).to receive(:connect_nonblock)
       allow(@simple_socket_handle).to receive(:setsockopt)
+      allow(@simple_socket_handle).to receive(:wait_readable)
+      allow(@simple_socket_handle).to receive(:wait_writable)
 
-      @handle = double(double("SSLHandle", :connect_nonblock => true, :post_connection_check => true), :closed? => false)
-      allow(@handle).to receive(:connect_nonblock)
+      @handle = double("SSLHandle", :closed? => false)
+      allow(@handle).to receive(:connect).and_return(true)
+      allow(@handle).to receive(:connect_nonblock).and_return(@handle)
       allow(@handle).to receive(:close)
       allow(@handle).to receive(:post_connection_check)
+      allow(@handle).to receive(:sync_close=)
       allow(@handle).to receive(:to_io).and_return(@simple_socket_handle)
 
-      allow(::Socket).to receive(:new).and_return(@simple_socket_handle)
+      allow(@addrinfo).to receive(:connect).and_return(@simple_socket_handle)
+      allow(Addrinfo).to receive(:foreach).and_yield(@addrinfo)
       allow(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(@handle)
     end
 
     it_should_behave_like "a socket"
 
     it "should raise a TransportException when it cannot open a ssl socket" do
-      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
+      allow(Addrinfo).to receive(:foreach).and_raise(SocketError.new("lookup failed"))
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause).to be_a(SocketError)
+      end
     end
 
     it "should open a ::Socket with default args" do
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
       expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(@simple_socket_handle, nil).and_return(@handle)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect).and_return(true)
       expect(@handle).to receive(:post_connection_check).with('localhost')
       @socket.open
     end
 
     it "should accept host/port options" do
-      handle = double("Handle", :connect_nonblock => true, :setsockopt => nil)
-      allow(::Socket).to receive(:new).and_return(handle)
-      expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect(::Socket).to receive(:sockaddr_in)
+      handle = double("Handle", :closed? => false)
+      allow(handle).to receive(:close)
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 100.0)
+      expect(handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(Addrinfo).to receive(:foreach).with("my.domain", 1234, nil, :STREAM).and_yield(@addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 6000).and_return(handle)
       expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(handle, nil).and_return(@handle)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(@handle)
       expect(@handle).to receive(:post_connection_check).with('my.domain')
       Thrift::SSLSocket.new('my.domain', 1234, 6000, nil).open
     end
@@ -71,6 +88,150 @@ describe 'SSLSocket' do
       expect(Thrift::SSLSocket.new('localhost', 8080, 5, @context).ssl_context).to eq(@context)
     end
 
+    it "should treat zero timeout as blocking for open and handshake" do
+      @socket.timeout = 0
+
+      expect(@addrinfo).to receive(:connect).with(no_args).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect).and_return(true)
+      expect(@handle).not_to receive(:connect_nonblock)
+      expect(@handle).to receive(:post_connection_check).with('localhost')
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should use the remaining timeout across ssl wait states" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 102.0, 104.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(:wait_readable)
+      expect(@simple_socket_handle).to receive(:wait_readable).with(3.0).ordered.and_return(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(:wait_writable)
+      expect(@simple_socket_handle).to receive(:wait_writable).with(1.0).ordered.and_return(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('localhost')
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should share one timeout budget across tcp fallback and the ssl handshake" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 102.0, 103.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ECONNREFUSED)
+      expect(second_addrinfo).to receive(:connect).with(timeout: 3.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(:wait_readable)
+      expect(@simple_socket_handle).to receive(:wait_readable).with(2.0).ordered.and_return(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).ordered.and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('localhost')
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should continue to the next address after a tcp connect timeout during ssl open" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 103.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ETIMEDOUT)
+      expect(second_addrinfo).to receive(:connect).with(timeout: 2.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('localhost')
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should raise TIMED_OUT when ssl handshake wait times out" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 102.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(:wait_readable)
+      expect(@simple_socket_handle).to receive(:wait_readable).with(3.0).and_return(nil)
+      expect(@handle).to receive(:close)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+        expect(e.message).to eq("SSL socket: Timed out establishing session with localhost:9090")
+      end
+    end
+
+    it "should surface tcp open timeout before starting ssl" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ETIMEDOUT)
+      expect(OpenSSL::SSL::SSLSocket).not_to receive(:new)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+        expect(e.message).to eq("Socket: Timed out opening connection to localhost:9090")
+      end
+    end
+
+    it "should close the raw socket if ssl wrapper creation fails" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(@simple_socket_handle, nil).and_raise(StandardError.new("ssl init failed"))
+      expect(@simple_socket_handle).to receive(:close)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause.message).to eq("ssl init failed")
+      end
+    end
+
+    it "should close the ssl socket when post connection check fails" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('localhost').and_raise(StandardError.new("hostname mismatch"))
+      expect(@handle).to receive(:close)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause.message).to eq("hostname mismatch")
+      end
+    end
+
+    it "should close the ssl socket on an unexpected nonblocking handshake result" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_return(@simple_socket_handle)
+      expect(@simple_socket_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(@handle).to receive(:sync_close=).with(true)
+      expect(@handle).to receive(:connect_nonblock).with(exception: false).and_return(:unexpected)
+      expect(@handle).to receive(:close)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to include("unexpected SSL connect result")
+      end
+    end
+
     it "should delegate to_io to the underlying SSL socket handle" do
       @socket.open
       expect(@socket.to_io).to eq(@simple_socket_handle)

data/spec/struct_nested_containers_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/struct_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/support/header_protocol_helper.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
@@ -33,7 +34,7 @@ module HeaderProtocolHelper
   end
 
   def build_header_frame(header_data, payload = Thrift::Bytes.empty_byte_buffer, header_words: nil)
-    header_data = Thrift::Bytes.force_binary_encoding(header_data)
+    header_data = header_data.b
     if header_words.nil?
       padding = (4 - (header_data.bytesize % 4)) % 4
       header_data += "\x00" * padding

data/spec/thin_http_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

data/spec/types_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/union_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/unix_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
@@ -67,10 +68,25 @@ describe 'UNIXSocket' do
       expect(handle).to receive(:accept).and_return(sock)
       trans = double("UNIXSocket")
       expect(Thrift::UNIXSocket).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::UNIXServerSocket.new(@path, 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::UNIXServerSocket.new(@path, client_timeout: nil).client_timeout).to be_nil
+      expect(Thrift::UNIXServerSocket.new(@path, client_timeout: 0).client_timeout).to eq(0)
+    end
+
     it "should close the handle when closed" do
       handle = double("UNIXServer", :closed? => false)
       expect(UNIXServer).to receive(:new).with(@path).and_return(handle)

data/spec/uuid_validation_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