thrift 0.24.0 → 0.25.0

data/spec/socket_spec.rb

@@ -1,174 +0,0 @@
-# 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'
-require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
-
-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(:setsockopt)
-      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
-      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(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
-      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
-      expect(Thrift::Socket.new('localhost', 8080, 5).timeout).to eq(5)
-    end
-
-    it "should provide a reasonable to_s" do
-      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,168 +0,0 @@
-# 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'
-
-shared_examples_for "a socket" do
-  it "should open a socket" do
-    expect(@socket.open).to eq(@handle)
-  end
-
-  it "should be open whenever it has a handle" do
-    expect(@socket).not_to be_open
-    @socket.open
-    expect(@socket).to be_open
-    @socket.handle = nil
-    expect(@socket).not_to be_open
-    @socket.handle = @handle
-    @socket.close
-    expect(@socket).not_to be_open
-  end
-
-  it "should write data to the handle" do
-    @socket.open
-    expect(@handle).to receive(:write).with("foobar")
-    @socket.write("foobar")
-    expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
-    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-  end
-
-  it "should raise an error when it cannot read from the handle" do
-    @socket.open
-    expect(@handle).to receive(:readpartial).with(17).and_raise(StandardError)
-    expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-  end
-
-  it "should return the data read when reading from the handle works" do
-    @socket.open
-    expect(@handle).to receive(:readpartial).with(17).and_return("test data")
-    expect(@socket.read(17)).to eq("test data")
-  end
-
-  it "should declare itself as closed when it has an error" do
-    @socket.open
-    expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
-    expect(@socket).to be_open
-    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-    expect(@socket).not_to be_open
-  end
-
-  it "should raise an error when the stream is closed" do
-    @socket.open
-    allow(@handle).to receive(:closed?).and_return(true)
-    expect(@socket).not_to be_open
-    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException, "closed stream") { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-    expect { @socket.read(10) }.to raise_error(Thrift::TransportException, "closed stream") { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
-  end
-
-  it "should support the timeout accessor for read" do
-    @socket.timeout = 3
-    @socket.open
-    expect(@handle).to receive(:read_nonblock).with(17).and_raise(IO::EAGAINWaitReadable)
-    expect(IO).to receive(:select) do |rd, wr, err, timeout|
-      expect(rd).to eq([@handle])
-      expect(wr).to be_nil
-      expect(err).to be_nil
-      expect(timeout).to be > 0
-      expect(timeout).to be <= 3
-      [[@handle], [], []]
-    end
-    expect(@handle).to receive(:read_nonblock).with(17).and_return("test data")
-    expect(@socket.read(17)).to eq("test data")
-  end
-
-  it "should support the timeout accessor for write" do
-    @socket.timeout = 3
-    @socket.open
-    write_calls = 0
-    expect(@handle).to receive(:write_nonblock).exactly(3).times do |chunk|
-      write_calls += 1
-      case write_calls
-      when 1
-        expect(chunk).to eq("test data")
-        raise IO::EAGAINWaitWritable
-      when 2
-        expect(chunk).to eq("test data")
-        4
-      when 3
-        expect(chunk).to eq(" data")
-        5
-      end
-    end
-    expect(IO).to receive(:select) do |rd, wr, err, timeout|
-      expect(rd).to be_nil
-      expect(wr).to eq([@handle])
-      expect(err).to be_nil
-      expect(timeout).to be > 0
-      expect(timeout).to be <= 3
-      [[], [@handle], []]
-    end
-    expect(@socket.write("test data")).to eq(9)
-  end
-
-  it "should raise an error when read times out" do
-    @socket.timeout = 0.5
-    @socket.open
-    expect(@handle).to receive(:read_nonblock).with(17).and_raise(IO::EAGAINWaitReadable)
-    expect(IO).to receive(:select).once { sleep(0.6); nil }
-    expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
-  end
-
-  it "should raise an error when write times out" do
-    @socket.timeout = 0.5
-    @socket.open
-    expect(@handle).to receive(:write_nonblock).with("test data").and_raise(IO::EAGAINWaitWritable)
-    expect(IO).to receive(:select).once { sleep(0.6); nil }
-    expect { @socket.write("test data") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
-  end
-
-  it "should read buffered SSL data without waiting on the raw socket again" do
-    @socket.timeout = 1
-    @socket.open
-
-    expect(@handle).to receive(:read_nonblock).with(4).ordered.and_raise(IO::EAGAINWaitReadable)
-    expect(IO).to receive(:select).once.ordered do |rd, wr, err, timeout|
-      expect(rd).to eq([@handle])
-      expect(wr).to be_nil
-      expect(err).to be_nil
-      expect(timeout).to be > 0
-      expect(timeout).to be <= 1
-      [[@handle], [], []]
-    end
-    expect(@handle).to receive(:read_nonblock).with(4).ordered.and_return("ABCD")
-    expect(@handle).to receive(:read_nonblock).with(5).ordered.and_return("12345")
-
-    expect(@socket.read(4)).to eq("ABCD")
-    expect(@socket.read(5)).to eq("12345")
-  end
-
-  it "should read without timeout using the blocking path" do
-    @socket.timeout = nil
-    @socket.open
-
-    expect(IO).not_to receive(:select)
-    expect(@handle).not_to receive(:read_nonblock)
-    expect(@handle).to receive(:readpartial).with(4).ordered.and_return("ABCD")
-    expect(@handle).to receive(:readpartial).with(5).ordered.and_return("12345")
-
-    expect(@socket.read(4)).to eq("ABCD")
-    expect(@socket.read(5)).to eq("12345")
-  end
-end

data/spec/spec_helper.rb

@@ -1,70 +0,0 @@
-# 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
-# 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 'rubygems'
-require 'rspec'
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. ext])
-
-# pretend we already loaded fastthread, otherwise the nonblocking_server_spec
-# will get screwed up
-# $" << 'fastthread.bundle'
-
-require 'thrift'
-
-unless Object.method_defined? :tap
-  # if Object#tap isn't defined, then add it; this should only happen in Ruby < 1.8.7
-  class Object
-    def tap(&block)
-      block.call(self)
-      self
-    end
-  end
-end
-
-RSpec.configure do |configuration|
-  configuration.before(:each) do
-    Thrift.type_checking = true
-  end
-end
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. test debug_proto gen-rb])
-require 'srv'
-require 'debug_proto_test_constants'
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[gen-rb])
-require 'thrift_spec_types'
-require 'nonblocking_service'
-
-module Fixtures
-  COMPACT_PROTOCOL_TEST_STRUCT = Thrift::Test::COMPACT_TEST.dup
-  COMPACT_PROTOCOL_TEST_STRUCT.a_binary = [0, 1, 2, 3, 4, 5, 6, 7, 8].pack('c*')
-  COMPACT_PROTOCOL_TEST_STRUCT.set_byte_map = nil
-  COMPACT_PROTOCOL_TEST_STRUCT.map_byte_map = nil
-end
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[gen-rb/flat])
-
-if defined?(GC.verify_compaction_references) == 'method'
-  # This method was added in Ruby 3.0.0. Calling it this way asks the GC to
-  # move objects around, helping to find object movement bugs.
-  GC.verify_compaction_references(double_heap: true, toward: :empty)
-end

data/spec/ssl_server_socket_spec.rb

@@ -1,85 +0,0 @@
-# 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'
-require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
-
-describe 'SSLServerSocket' do
-  describe Thrift::SSLServerSocket do
-    before(:each) do
-      @socket = Thrift::SSLServerSocket.new(1234)
-    end
-
-    it "should delegate to_io to the underlying SSL server handle" do
-      tcp_server = double("TCPServer")
-      ssl_server = double("SSLServer")
-
-      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)
-      allow(ssl_server).to receive(:to_io).and_return(tcp_server)
-
-      @socket.listen
-      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
-  end
-end