thrift 0.23.0 → 0.25.0

data/spec/nonblocking_server_spec.rb

@@ -1,361 +0,0 @@
-#
-# 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 'timeout'
-
-describe 'NonblockingServer' do
-  class Handler
-    def initialize
-      @queue = Queue.new
-    end
-
-    attr_accessor :server
-
-    def greeting(english)
-      if english
-        SpecNamespace::Hello.new
-      else
-        SpecNamespace::Hello.new(:greeting => "Aloha!")
-      end
-    end
-
-    def block
-      @queue.pop
-    end
-
-    def unblock(n)
-      n.times { @queue.push true }
-    end
-
-    def sleep(time)
-      Kernel.sleep time
-    end
-
-    def shutdown
-      @server.shutdown(0, false)
-    end
-  end
-
-  class SpecTransport < Thrift::BaseTransport
-    def initialize(transport, queue)
-      @transport = transport
-      @queue = queue
-      @flushed = false
-    end
-
-    def open?
-      @transport.open?
-    end
-
-    def open
-      @transport.open
-    end
-
-    def close
-      @transport.close
-    end
-
-    def read(sz)
-      @transport.read(sz)
-    end
-
-    def write(buf, sz = nil)
-      @transport.write(buf, sz)
-    end
-
-    def flush
-      @queue.push :flushed unless @flushed or @queue.nil?
-      @flushed = true
-      @transport.flush
-    end
-  end
-
-  class SpecServerSocket < Thrift::ServerSocket
-    def initialize(host, port, queue)
-      super(host, port)
-      @queue = queue
-    end
-
-    def listen
-      super
-      @queue.push :listen
-    end
-  end
-
-  describe Thrift::NonblockingServer do
-    before(:each) do
-      @port = 43251
-      handler = Handler.new
-      processor = SpecNamespace::NonblockingService::Processor.new(handler)
-      queue = Queue.new
-      @transport = SpecServerSocket.new('localhost', @port, queue)
-      transport_factory = Thrift::FramedTransportFactory.new
-      logger = Logger.new(STDERR)
-      logger.level = Logger::WARN
-      @server = Thrift::NonblockingServer.new(processor, @transport, transport_factory, nil, 5, logger)
-      handler.server = @server
-      @server_thread = Thread.new(Thread.current) do |master_thread|
-        begin
-          @server.serve
-        rescue => e
-          p e
-          puts e.backtrace * "\n"
-          master_thread.raise e
-        end
-      end
-      queue.pop
-
-      @clients = []
-      @catch_exceptions = false
-    end
-
-    after(:each) do
-      @clients.each { |client, trans| trans.close }
-      # @server.shutdown(1)
-      @server_thread.kill
-      @transport.close
-    end
-
-    def setup_client(queue = nil)
-      transport = SpecTransport.new(Thrift::FramedTransport.new(Thrift::Socket.new('localhost', @port)), queue)
-      protocol = Thrift::BinaryProtocol.new(transport)
-      client = SpecNamespace::NonblockingService::Client.new(protocol)
-      transport.open
-      @clients << [client, transport]
-      client
-    end
-
-    def setup_client_thread(result)
-      queue = Queue.new
-      Thread.new do
-        begin
-          client = setup_client
-          while (cmd = queue.pop)
-            msg, *args = cmd
-            case msg
-            when :block
-              result << client.block
-            when :unblock
-              client.unblock(args.first)
-            when :hello
-              result << client.greeting(true) # ignore result
-            when :sleep
-              client.sleep(args[0] || 0.5)
-              result << :slept
-            when :shutdown
-              client.shutdown
-            when :exit
-              result << :done
-              break
-            end
-          end
-          @clients.each { |c, t| t.close and break if c == client } # close the transport
-        rescue => e
-          raise e unless @catch_exceptions
-        end
-      end
-      queue
-    end
-
-    it "should handle basic message passing" do
-      client = setup_client
-      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
-      expect(client.greeting(false)).to eq(SpecNamespace::Hello.new(:greeting => 'Aloha!'))
-      @server.shutdown
-    end
-
-    it "should handle concurrent clients" do
-      queue = Queue.new
-      trans_queue = Queue.new
-      4.times do
-        Thread.new(Thread.current) do |main_thread|
-          begin
-            queue.push setup_client(trans_queue).block
-          rescue => e
-            main_thread.raise e
-          end
-        end
-      end
-      4.times { trans_queue.pop }
-      setup_client.unblock(4)
-      4.times { expect(queue.pop).to be_truthy }
-      @server.shutdown
-    end
-
-    it "should handle messages from more than 5 long-lived connections" do
-      queues = []
-      result = Queue.new
-      7.times do |i|
-        queues << setup_client_thread(result)
-        Thread.pass if i == 4 # give the server time to accept connections
-      end
-      client = setup_client
-      # block 4 connections
-      4.times { |i| queues[i] << :block }
-      queues[4] << :hello
-      queues[5] << :hello
-      queues[6] << :hello
-      3.times { expect(result.pop).to eq(SpecNamespace::Hello.new) }
-      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
-      queues[5] << [:unblock, 4]
-      4.times { expect(result.pop).to be_truthy }
-      queues[2] << :hello
-      expect(result.pop).to eq(SpecNamespace::Hello.new)
-      expect(client.greeting(false)).to eq(SpecNamespace::Hello.new(:greeting => 'Aloha!'))
-      7.times { queues.shift << :exit }
-      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
-      @server.shutdown
-    end
-
-    it "should shut down when asked" do
-      # connect first to ensure it's running
-      client = setup_client
-      client.greeting(false) # force a message pass
-      @server.shutdown
-      expect(@server_thread.join(2)).to be_an_instance_of(Thread)
-    end
-
-    it "should continue processing active messages when shutting down" do
-      result = Queue.new
-      client = setup_client_thread(result)
-      client << :sleep
-      sleep 0.1 # give the server time to start processing the client's message
-      @server.shutdown
-      expect(@server_thread.join(2)).to be_an_instance_of(Thread)
-      expect(result.pop).to eq(:slept)
-    end
-
-    it "should kill active messages when they don't expire while shutting down" do
-      result = Queue.new
-      client = setup_client_thread(result)
-      client << [:sleep, 10.0]
-      sleep 0.1 # start processing the client's message
-      @server.shutdown(1)
-      @catch_exceptions = true
-      expect(@server_thread.join(3)).not_to be_nil
-      expect(result).to be_empty
-    end
-
-    it "should allow shutting down in response to a message" do
-      client = setup_client
-      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
-      client.shutdown
-      expect(@server_thread.join(2)).not_to be_nil
-    end
-  end
-
-  describe "#{Thrift::NonblockingServer} with TLS transport" do
-    before(:each) do
-      @port = available_port
-      handler = Handler.new
-      processor = SpecNamespace::NonblockingService::Processor.new(handler)
-      @transport = Thrift::SSLServerSocket.new('localhost', @port, create_server_ssl_context)
-      transport_factory = Thrift::FramedTransportFactory.new
-      logger = Logger.new(STDERR)
-      logger.level = Logger::WARN
-      @server = Thrift::NonblockingServer.new(processor, @transport, transport_factory, nil, 5, logger)
-      handler.server = @server
-
-      @server_thread = Thread.new(Thread.current) do |master_thread|
-        begin
-          @server.serve
-        rescue => e
-          master_thread.raise e
-        end
-      end
-
-      @clients = []
-      wait_until_listening
-    end
-
-    after(:each) do
-      @clients.each(&:close)
-      @server.shutdown if @server
-      @server_thread.join(2) if @server_thread
-      @transport.close if @transport
-    end
-
-    it "should handle requests over TLS" do
-      expect(@server_thread).to be_alive
-
-      client = setup_tls_client
-      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
-
-      @server.shutdown
-      expect(@server_thread.join(2)).to be_an_instance_of(Thread)
-    end
-
-    def setup_tls_client
-      transport = Thrift::FramedTransport.new(
-        Thrift::SSLSocket.new('localhost', @port, nil, create_client_ssl_context)
-      )
-      protocol = Thrift::BinaryProtocol.new(transport)
-      client = SpecNamespace::NonblockingService::Client.new(protocol)
-      transport.open
-      @clients << transport
-      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
-
-    def create_server_ssl_context
-      OpenSSL::SSL::SSLContext.new.tap do |ctx|
-        ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        if ctx.respond_to?(:min_version=) && OpenSSL::SSL.const_defined?(:TLS1_2_VERSION)
-          ctx.min_version = OpenSSL::SSL::TLS1_2_VERSION
-        end
-        ctx.ca_file = File.join(ssl_keys_dir, 'CA.pem')
-        ctx.cert = OpenSSL::X509::Certificate.new(File.read(File.join(ssl_keys_dir, 'server.crt')))
-        ctx.cert_store = OpenSSL::X509::Store.new
-        ctx.cert_store.add_file(File.join(ssl_keys_dir, 'client.pem'))
-        ctx.key = OpenSSL::PKey::RSA.new(File.read(File.join(ssl_keys_dir, 'server.key')))
-      end
-    end
-
-    def create_client_ssl_context
-      OpenSSL::SSL::SSLContext.new.tap do |ctx|
-        ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        if ctx.respond_to?(:min_version=) && OpenSSL::SSL.const_defined?(:TLS1_2_VERSION)
-          ctx.min_version = OpenSSL::SSL::TLS1_2_VERSION
-        end
-        ctx.ca_file = File.join(ssl_keys_dir, 'CA.pem')
-        ctx.cert = OpenSSL::X509::Certificate.new(File.read(File.join(ssl_keys_dir, 'client.crt')))
-        ctx.cert_store = OpenSSL::X509::Store.new
-        ctx.cert_store.add_file(File.join(ssl_keys_dir, 'server.pem'))
-        ctx.key = OpenSSL::PKey::RSA.new(File.read(File.join(ssl_keys_dir, 'client.key')))
-      end
-    end
-  end
-end

data/spec/processor_spec.rb

@@ -1,79 +0,0 @@
-#
-# 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 'Processor' do
-  class ProcessorSpec
-    include Thrift::Processor
-  end
-
-  describe Thrift::Processor do
-    before(:each) do
-      @processor = ProcessorSpec.new(double("MockHandler"))
-      @prot = double("MockProtocol")
-    end
-
-    def mock_trans(obj)
-      expect(obj).to receive(:trans).ordered do
-        double("trans").tap do |trans|
-          expect(trans).to receive(:flush).ordered
-        end
-      end
-    end
-
-    it "should call process_<message> when it receives that message" do
-      expect(@prot).to receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 17]
-      expect(@processor).to receive(:process_testMessage).with(17, @prot, @prot).ordered
-      expect(@processor.process(@prot, @prot)).to eq(true)
-    end
-
-    it "should raise an ApplicationException when the received message cannot be processed" do
-      expect(@prot).to receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 4]
-      expect(@prot).to receive(:skip).with(Thrift::Types::STRUCT).ordered
-      expect(@prot).to receive(:read_message_end).ordered
-      expect(@prot).to receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::EXCEPTION, 4).ordered
-      e = double(Thrift::ApplicationException)
-      expect(e).to receive(:write).with(@prot).ordered
-      expect(Thrift::ApplicationException).to receive(:new).with(Thrift::ApplicationException::UNKNOWN_METHOD, "Unknown function testMessage").and_return(e)
-      expect(@prot).to receive(:write_message_end).ordered
-      mock_trans(@prot)
-      @processor.process(@prot, @prot)
-    end
-
-    it "should pass args off to the args class" do
-      args_class = double("MockArgsClass")
-      args = double("#<MockArgsClass:mock>").tap do |args|
-        expect(args).to receive(:read).with(@prot).ordered
-      end
-      expect(args_class).to receive(:new).and_return args
-      expect(@prot).to receive(:read_message_end).ordered
-      expect(@processor.read_args(@prot, args_class)).to eql(args)
-    end
-
-    it "should write out a reply when asked" do
-      expect(@prot).to receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::REPLY, 23).ordered
-      result = double("MockResult")
-      expect(result).to receive(:write).with(@prot).ordered
-      expect(@prot).to receive(:write_message_end).ordered
-      mock_trans(@prot)
-      @processor.write_result(result, @prot, 'testMessage', 23)
-    end
-  end
-end

data/spec/serializer_spec.rb

@@ -1,66 +0,0 @@
-#
-# 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 'Serializer' do
-  describe Thrift::Serializer do
-    it "should serialize structs to binary by default" do
-      serializer = Thrift::Serializer.new(Thrift::BinaryProtocolAcceleratedFactory.new)
-      data = serializer.serialize(SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!"))
-      expect(data).to eq("\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00")
-    end
-
-    it "should serialize structs to the given protocol" do
-      protocol = Thrift::BaseProtocol.new(double("transport"))
-      expect(protocol).to receive(:write_struct_begin).with("SpecNamespace::Hello")
-      expect(protocol).to receive(:write_field_begin).with("greeting", Thrift::Types::STRING, 1)
-      expect(protocol).to receive(:write_string).with("Good day")
-      expect(protocol).to receive(:write_field_end)
-      expect(protocol).to receive(:write_field_stop)
-      expect(protocol).to receive(:write_struct_end)
-      protocol_factory = double("ProtocolFactory")
-      allow(protocol_factory).to receive(:get_protocol).and_return(protocol)
-      serializer = Thrift::Serializer.new(protocol_factory)
-      serializer.serialize(SpecNamespace::Hello.new(:greeting => "Good day"))
-    end
-  end
-
-  describe Thrift::Deserializer do
-    it "should deserialize structs from binary by default" do
-      deserializer = Thrift::Deserializer.new
-      data = "\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00"
-      expect(deserializer.deserialize(SpecNamespace::Hello.new, data)).to eq(SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!"))
-    end
-
-    it "should deserialize structs from the given protocol" do
-      protocol = Thrift::BaseProtocol.new(double("transport"))
-      expect(protocol).to receive(:read_struct_begin).and_return("SpecNamespace::Hello")
-      expect(protocol).to receive(:read_field_begin).and_return(["greeting", Thrift::Types::STRING, 1],
-                                                            [nil, Thrift::Types::STOP, 0])
-      expect(protocol).to receive(:read_string).and_return("Good day")
-      expect(protocol).to receive(:read_field_end)
-      expect(protocol).to receive(:read_struct_end)
-      protocol_factory = double("ProtocolFactory")
-      allow(protocol_factory).to receive(:get_protocol).and_return(protocol)
-      deserializer = Thrift::Deserializer.new(protocol_factory)
-      expect(deserializer.deserialize(SpecNamespace::Hello.new, "")).to eq(SpecNamespace::Hello.new(:greeting => "Good day"))
-    end
-  end
-end

data/spec/server_socket_spec.rb

@@ -1,84 +0,0 @@
-#
-# 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 'Thrift::ServerSocket' do
-  describe Thrift::ServerSocket do
-    before(:each) do
-      @socket = Thrift::ServerSocket.new(1234)
-    end
-
-    it "should create a handle when calling listen" do
-      expect(TCPServer).to receive(:new).with(nil, 1234)
-      @socket.listen
-    end
-
-    it "should accept an optional host argument" do
-      @socket = Thrift::ServerSocket.new('localhost', 1234)
-      expect(TCPServer).to receive(:new).with('localhost', 1234)
-      @socket.to_s == "server(localhost:1234)"
-      @socket.listen
-    end
-
-    it "should create a Thrift::Socket to wrap accepted sockets" do
-      handle = double("TCPServer")
-      expect(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)
-      @socket.listen
-      sock = double("sock")
-      expect(sock).to receive(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-      expect(handle).to receive(:accept).and_return(sock)
-      trans = double("Socket")
-      expect(Thrift::Socket).to receive(:new).and_return(trans)
-      expect(trans).to receive(:handle=).with(sock)
-      expect(@socket.accept).to eq(trans)
-    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)
-      @socket.listen
-      expect(handle).to receive(:close)
-      @socket.close
-    end
-
-    it "should return nil when accepting if there is no handle" do
-      expect(@socket.accept).to be_nil
-    end
-
-    it "should return true for closed? when appropriate" do
-      handle = double("TCPServer", :closed? => false)
-      allow(TCPServer).to receive(:new).and_return(handle)
-      @socket.listen
-      expect(@socket).not_to be_closed
-      allow(handle).to receive(:close)
-      @socket.close
-      expect(@socket).to be_closed
-      @socket.listen
-      expect(@socket).not_to be_closed
-      allow(handle).to receive(:closed?).and_return(true)
-      expect(@socket).to be_closed
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@socket.to_s).to eq("socket(:1234)")
-    end
-  end
-end