upfluence-thrift 2.7.5 → 2.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7364f74deded6f763d331becc4b5daae61421b94363b280eefbf2d8e7ae6d04
-  data.tar.gz: ce0fdd32e91d447f715dc703dca1473130b2c1f63472fefe0e306bf830f7ee4f
+  metadata.gz: 8e31952e8e892fc4b82c5a19ac4145bf6c8d439474b83b8162119a11cedc5b0d
+  data.tar.gz: '049b17f3c6bba2b2ce85aff58417785465614992435667036fcda62bf4f43fa9'
 SHA512:
-  metadata.gz: 00d26a6747c4af8df633b615759e53b7386de509339b8b3c1e56f9649c17ccbba1e94a06c9a607b45385b40c0b250bc30afece40bca46e9ea4a66ca8edd1d55e
-  data.tar.gz: fb343c067f283d0ae87e93de2d5215907e9d4020997129fde989378e5538dce8d3da94521d1796e42d30ace9fd4f5044ef80fa1c56ae8580be544464e6ecee40
+  metadata.gz: b5a53855250a59549aaab99463b1fd8512c9d2379f6dfbee1407357f3270b8717ed009319923a64d023402ff50c01d7d62fb413c064d9e31cf94656529555f83
+  data.tar.gz: 98d79404c6044387670b06ceef345acdfa70d618d645da24d02b1ff191eef1cdf8a22723ce06b13de8a4b59653a9a6daec6b4639fb5b538ad283229458743887

data/lib/thrift/processor.rb

@@ -59,22 +59,7 @@ module Thrift
 
         write_result(result, oprot, seqid)
       rescue => e
-        write_exception(e, oprot, seqid)
-      end
-
-      def write_exception(exception, oprot, seqid)
-        oprot.write_message_begin(@fname, MessageTypes::EXCEPTION, seqid)
-
-        unless exception.is_a? ApplicationException
-          exception = ApplicationException.new(
-            ApplicationException::INTERNAL_ERROR,
-            "Internal error processing #{@fname}: #{exception.class}: #{exception}"
-          )
-        end
-
-        exception.write(oprot)
-        oprot.write_message_end
-        oprot.trans.flush
+        Processor.write_exception(e, oprot, @fname, seqid)
       end
 
       def write_result(result, oprot, seqid)
@@ -131,11 +116,18 @@ module Thrift
     end
 
     def process(iprot, oprot)
-      name, _type, seqid = iprot.read_message_begin
+      name, type, seqid = iprot.read_message_begin
 
       mth = "process_#{name}"
       if respond_to?(mth)
-        send(mth, seqid, iprot, oprot)
+        begin
+          send(mth, seqid, iprot, oprot)
+        rescue StandardError => e
+          raise e if type == MessageTypes::ONEWAY
+
+          Processor.write_internal_error(e, oprot, name, seqid)
+        end
+
         return true
       end
 
@@ -144,8 +136,35 @@ module Thrift
       ).process(seqid, iprot, oprot)
     end
 
+    def self.write_exception(exception, oprot, name, seqid)
+      oprot.write_message_begin(name, MessageTypes::EXCEPTION, seqid)
+
+      unless exception.is_a? ApplicationException
+        exception = ApplicationException.new(
+          ApplicationException::INTERNAL_ERROR,
+          "Internal error processing #{name}: #{exception.class}: #{exception}"
+        )
+      end
+
+      exception.write(oprot)
+      oprot.write_message_end
+      oprot.trans.flush
+    end
+
+    def self.write_internal_error(exception, oprot, name, seqid)
+      write_exception(
+        ApplicationException.new(
+          ApplicationException::INTERNAL_ERROR,
+          "Internal error processing #{name}: #{exception.class}: #{exception}"
+        ),
+        oprot,
+        name,
+        seqid
+      )
+    end
+
     def build_processor(name, info)
-      if info[:result_klass].nil?
+      if info[:result_klass].nil? && info[:oneway]
         UnaryProcessor
       elsif info[:stream_klass].nil? && info[:sink_klass].nil?
         BinaryProcessor
@@ -173,21 +192,6 @@ module Thrift
         args
       end
 
-      def write_exception(exception, oprot, name, seqid)
-        oprot.write_message_begin(name, MessageTypes::EXCEPTION, seqid)
-
-        unless exception.is_a? ApplicationException
-          exception = ApplicationException.new(
-            ApplicationException::INTERNAL_ERROR,
-            "Internal error processing #{name}: #{exception.class}: #{exception}"
-          )
-        end
-
-        exception.write(oprot)
-        oprot.write_message_end
-        oprot.trans.flush
-      end
-
       def write_result(result, oprot, seqid)
         oprot.write_message_begin(@name, MessageTypes::REPLY, seqid)
         result.write(oprot)
@@ -236,18 +240,10 @@ module Thrift
 
         true
       rescue ApplicationException => e
-        write_exception(e, oprot, @name, seqid)
+        Processor.write_exception(e, oprot, @name, seqid)
         true
       rescue StandardError => e
-        write_exception(
-          ApplicationException.new(
-            ApplicationException::INTERNAL_ERROR,
-            "Internal error processing #{@name}: #{e.class}: #{e}"
-          ),
-          oprot,
-          @name,
-          seqid
-        )
+        Processor.write_internal_error(e, oprot, @name, seqid)
         true
       end
 
@@ -400,7 +396,7 @@ module Thrift
       def process(seqid, iprot, oprot)
         iprot.skip(Types::STRUCT)
         iprot.read_message_end
-        write_exception(
+        Processor.write_exception(
           ApplicationException.new(
             ApplicationException::UNKNOWN_METHOD,
             'Unknown function ' + @name,

data/spec/processor_spec.rb

@@ -19,73 +19,200 @@
 
 require 'spec_helper'
 
-describe 'Processor' do
-  class ProcessorSpec
-    include Thrift::Processor
+describe Thrift::Processor do
+  class EmptyArgs
+    include Thrift::Struct_Union
+    include Thrift::Struct
+
+    FIELDS = {}.freeze
+
+    def struct_fields
+      FIELDS
+    end
+
+    def validate; end
   end
 
-  describe Thrift::Processor do
-    before(:each) do
-      @processor = ProcessorSpec.new(double('MockHandler'))
-      @prot = double('MockProtocol')
+  class EmptyResult
+    include Thrift::Struct_Union
+    include Thrift::Struct
+
+    FIELDS = {}.freeze
+
+    def struct_fields
+      FIELDS
     end
 
-    def mock_trans(obj)
-      expect(obj).to receive(:trans).ordered do
-        double('trans').tap do |trans|
-          expect(trans).to receive(:flush).ordered
-        end
+    def validate; end
+  end
+
+  class LegacyProcessor
+    include Thrift::Processor
+
+    def process_ping(seqid, iprot, oprot)
+      args = read_args(iprot, EmptyArgs)
+      result = @middleware.handle_binary('ping', args) do
+        @handler.ping
+        EmptyResult.new
       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)
+      write_result(result, oprot, 'ping', seqid)
     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 = Thrift::ApplicationException.new(
-        Thrift::ApplicationException::UNKNOWN_METHOD,
-        'Unknown function testMessage'
-      )
-      expect(Thrift::ApplicationException).to receive(:new).with(Thrift::ApplicationException::UNKNOWN_METHOD,
-                                                                 'Unknown function testMessage').and_return(e)
-      expect(@prot).to receive(:write_struct_begin).with('Thrift::ApplicationException').ordered
-      expect(@prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1).ordered
-      expect(@prot).to receive(:write_string).with('Unknown function testMessage').ordered
-      expect(@prot).to receive(:write_field_end).ordered
-      expect(@prot).to receive(:write_field_begin).with('type', Thrift::Types::I32, 2).ordered
-      expect(@prot).to receive(:write_i32).with(Thrift::ApplicationException::UNKNOWN_METHOD).ordered
-      expect(@prot).to receive(:write_field_end).ordered
-      expect(@prot).to receive(:write_field_stop).ordered
-      expect(@prot).to receive(:write_struct_end).ordered
-      expect(@prot).to receive(:write_message_end).ordered
-      mock_trans(@prot)
-      @processor.process(@prot, @prot)
-    end
+    def process_notify(_seqid, iprot, _oprot)
+      args = read_args(iprot, EmptyArgs)
 
-    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
+      @middleware.handle_unary('notify', args) do
+        @handler.notify
       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
+  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
+  class CurrentProcessor
+    include Thrift::Processor
+
+    METHODS = {
+      'ping' => {
+        args_klass:   EmptyArgs,
+        result_klass: EmptyResult,
+        args:         [],
+        exceptions:   {},
+        oneway:       false
+      }
+    }.freeze
+  end
+
+  def request_protocol(name, type = Thrift::MessageTypes::CALL, seqid = 17)
+    trans = Thrift::MemoryBufferTransport.new
+    protocol = Thrift::BinaryProtocol.new(trans)
+    protocol.write_message_begin(name, type, seqid)
+    EmptyArgs.new.write(protocol)
+    protocol.write_message_end
+
+    Thrift::BinaryProtocol.new(trans)
+  end
+
+  def output_protocol
+    trans = Thrift::MemoryBufferTransport.new
+
+    [Thrift::BinaryProtocol.new(trans), trans]
+  end
+
+  def read_exception(protocol)
+    name, type, seqid = protocol.read_message_begin
+    exception = Thrift::ApplicationException.new
+    exception.read(protocol)
+    protocol.read_message_end
+
+    {
+      name:           name,
+      type:           type,
+      seqid:          seqid,
+      exception_type: exception.type,
+      message:        exception.message
+    }
+  end
+
+  it 'processes requests with a legacy generated stub' do
+    handler = double('handler', ping: nil)
+    processor = LegacyProcessor.new(handler)
+    oprot, trans = output_protocol
+
+    expect(processor.process(request_protocol('ping'), oprot)).to eq(true)
+    expect(oprot.read_message_begin).to eq(
+      ['ping', Thrift::MessageTypes::REPLY, 17]
+    )
+
+    EmptyResult.new.read(oprot)
+    oprot.read_message_end
+
+    expect(trans.available).to eq(0)
+  end
+
+  it 'writes internal errors raised by a legacy generated stub' do
+    handler = double('handler')
+    allow(handler).to receive(:ping).and_raise(StandardError, 'boom')
+    processor = LegacyProcessor.new(handler)
+    oprot, = output_protocol
+
+    expect(processor.process(request_protocol('ping'), oprot)).to eq(true)
+    expect(read_exception(oprot)).to eq(
+      name:           'ping',
+      type:           Thrift::MessageTypes::EXCEPTION,
+      seqid:          17,
+      exception_type: Thrift::ApplicationException::INTERNAL_ERROR,
+      message:        'Internal error processing ping: StandardError: boom'
+    )
+  end
+
+  it 'raises errors from a legacy oneway method without writing a response' do
+    handler = double('handler')
+    allow(handler).to receive(:notify).and_raise(StandardError, 'boom')
+    processor = LegacyProcessor.new(handler)
+    oprot, trans = output_protocol
+
+    expect do
+      processor.process(
+        request_protocol('notify', Thrift::MessageTypes::ONEWAY),
+        oprot
+      )
+    end.to raise_error(StandardError, 'boom')
+    expect(trans.available).to eq(0)
+  end
+
+  it 'writes an unknown method exception' do
+    processor = CurrentProcessor.new(double('handler'))
+    oprot, = output_protocol
+
+    expect(
+      processor.process(
+        request_protocol('missing', Thrift::MessageTypes::CALL, 4),
+        oprot
+      )
+    ).to eq(false)
+    expect(read_exception(oprot)).to eq(
+      name:           'missing',
+      type:           Thrift::MessageTypes::EXCEPTION,
+      seqid:          4,
+      exception_type: Thrift::ApplicationException::UNKNOWN_METHOD,
+      message:        'Unknown function missing'
+    )
+  end
+
+  it 'writes internal errors raised by a current processor' do
+    handler = double('handler')
+    allow(handler).to receive(:ping).and_raise(StandardError, 'boom')
+    processor = CurrentProcessor.new(handler)
+    oprot, = output_protocol
+
+    expect(processor.process(request_protocol('ping'), oprot)).to eq(true)
+    expect(read_exception(oprot)).to eq(
+      name:           'ping',
+      type:           Thrift::MessageTypes::EXCEPTION,
+      seqid:          17,
+      exception_type: Thrift::ApplicationException::INTERNAL_ERROR,
+      message:        'Internal error processing ping: StandardError: boom'
+    )
+  end
+
+  it 'preserves application exceptions raised by a current processor' do
+    handler = double('handler')
+    allow(handler).to receive(:ping).and_raise(
+      Thrift::ApplicationException.new(
+        Thrift::ApplicationException::PROTOCOL_ERROR,
+        'invalid request'
+      )
+    )
+    processor = CurrentProcessor.new(handler)
+    oprot, = output_protocol
+
+    expect(processor.process(request_protocol('ping'), oprot)).to eq(true)
+    expect(read_exception(oprot)).to eq(
+      name:           'ping',
+      type:           Thrift::MessageTypes::EXCEPTION,
+      seqid:          17,
+      exception_type: Thrift::ApplicationException::PROTOCOL_ERROR,
+      message:        'invalid request'
+    )
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: upfluence-thrift
 version: !ruby/object:Gem::Version
-  version: 2.7.5
+  version: 2.7.7
 platform: ruby
 authors:
 - Thrift Developers
 bindir: bin
 cert_chain: []
-date: 2026-07-28 00:00:00.000000000 Z
+date: 2026-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec