upfluence-thrift 2.7.4 → 2.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a0063f65dcbef1241a6a3c5833985d900ec665e136ca644335b9b14b8bdb153
-  data.tar.gz: 6c483db58e479281a16c09477699081a21ff3110c698d712ac8156769c795f5e
+  metadata.gz: 8e31952e8e892fc4b82c5a19ac4145bf6c8d439474b83b8162119a11cedc5b0d
+  data.tar.gz: '049b17f3c6bba2b2ce85aff58417785465614992435667036fcda62bf4f43fa9'
 SHA512:
-  metadata.gz: 95d2907344606615a4947fc6c2e9046d557712f14e52b6e546be9d72ea47c86d1d1e60fcd11ab4a08d9182a22f8ee92ee42606a31d025600d6b8e44af6e65560
-  data.tar.gz: eb411a032c23bae788deef5da6e2b88b52675d0f52eed9a0d418ef552655779459f03596b4133d75bc6469de40227ba82aa55ba3e838f294244519b7e63d4e70
+  metadata.gz: b5a53855250a59549aaab99463b1fd8512c9d2379f6dfbee1407357f3270b8717ed009319923a64d023402ff50c01d7d62fb413c064d9e31cf94656529555f83
+  data.tar.gz: 98d79404c6044387670b06ceef345acdfa70d618d645da24d02b1ff191eef1cdf8a22723ce06b13de8a4b59653a9a6daec6b4639fb5b538ad283229458743887

data/lib/thrift/exceptions.rb

@@ -37,9 +37,12 @@ module Thrift
     MISSING_RESULT = 5
     INTERNAL_ERROR = 6
     PROTOCOL_ERROR = 7
-    INVALID_TRANSFORM = 8
+    INTERNAL_TIME_OUT_ERROR = 8
+    INVALID_TRANSFORM = 11
     INVALID_PROTOCOL = 9
     UNSUPPORTED_CLIENT_TYPE = 10
+    METHOD_NOT_IMPLEMENTED = 12
+
 
     attr_reader :type
 

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/lib/thrift/types/program_definition/program_definition_types.rb

@@ -40,6 +40,7 @@ module Thrift
         THRIFT_FIELD_INDEX_CONSTANTS = 8
         THRIFT_FIELD_INDEX_TYPEDEFS = 9
         THRIFT_FIELD_INDEX_ENUMS = 10
+        THRIFT_FIELD_INDEX_STDLIB = 11
 
         THRIFT_FIELD_NAME_LEGACY_ANNOTATIONS = {
         }.freeze
@@ -101,6 +102,12 @@ module Thrift
         THRIFT_FIELD_ENUMS_STRUCTURED_ANNOTATIONS = [
         ].freeze
 
+        THRIFT_FIELD_STDLIB_LEGACY_ANNOTATIONS = {
+        }.freeze
+
+        THRIFT_FIELD_STDLIB_STRUCTURED_ANNOTATIONS = [
+        ].freeze
+
         FIELDS = {
           THRIFT_FIELD_INDEX_NAME => {type: ::Thrift::Types::STRING, name: 'name', legacy_annotations: THRIFT_FIELD_NAME_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_NAME_STRUCTURED_ANNOTATIONS},
           THRIFT_FIELD_INDEX_PATH => {type: ::Thrift::Types::STRING, name: 'path', legacy_annotations: THRIFT_FIELD_PATH_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_PATH_STRUCTURED_ANNOTATIONS},
@@ -111,7 +118,8 @@ module Thrift
           THRIFT_FIELD_INDEX_SERVICES => {type: ::Thrift::Types::MAP, name: 'services', key: {type: ::Thrift::Types::STRING}, value: {type: ::Thrift::Types::STRUCT, class: ::Thrift::Types::Service_definition::ServiceDefinition}, legacy_annotations: THRIFT_FIELD_SERVICES_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_SERVICES_STRUCTURED_ANNOTATIONS},
           THRIFT_FIELD_INDEX_CONSTANTS => {type: ::Thrift::Types::MAP, name: 'constants', key: {type: ::Thrift::Types::STRING}, value: {type: ::Thrift::Types::STRUCT, class: ::Thrift::Types::Constant_definition::ConstantDefinition}, legacy_annotations: THRIFT_FIELD_CONSTANTS_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_CONSTANTS_STRUCTURED_ANNOTATIONS},
           THRIFT_FIELD_INDEX_TYPEDEFS => {type: ::Thrift::Types::MAP, name: 'typedefs', key: {type: ::Thrift::Types::STRING}, value: {type: ::Thrift::Types::STRUCT, class: ::Thrift::Types::Type_definition::TypeDefinition}, legacy_annotations: THRIFT_FIELD_TYPEDEFS_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_TYPEDEFS_STRUCTURED_ANNOTATIONS},
-          THRIFT_FIELD_INDEX_ENUMS => {type: ::Thrift::Types::MAP, name: 'enums', key: {type: ::Thrift::Types::STRING}, value: {type: ::Thrift::Types::STRUCT, class: ::Thrift::Types::Enum_definition::EnumDefinition}, legacy_annotations: THRIFT_FIELD_ENUMS_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_ENUMS_STRUCTURED_ANNOTATIONS}
+          THRIFT_FIELD_INDEX_ENUMS => {type: ::Thrift::Types::MAP, name: 'enums', key: {type: ::Thrift::Types::STRING}, value: {type: ::Thrift::Types::STRUCT, class: ::Thrift::Types::Enum_definition::EnumDefinition}, legacy_annotations: THRIFT_FIELD_ENUMS_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_ENUMS_STRUCTURED_ANNOTATIONS},
+          THRIFT_FIELD_INDEX_STDLIB => {type: ::Thrift::Types::BOOL, name: 'stdlib', legacy_annotations: THRIFT_FIELD_STDLIB_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_STDLIB_STRUCTURED_ANNOTATIONS}
         }.freeze
 
         def struct_fields; FIELDS; end
@@ -126,6 +134,7 @@ module Thrift
           raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field constants is unset!') unless @constants
           raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field typedefs is unset!') unless @typedefs
           raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field enums is unset!') unless @enums
+          raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field stdlib is unset!') if @stdlib.nil?
         end
 
         ::Thrift::Struct.generate_accessors self

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.4
+  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