upfluence-thrift 2.6.1 → 2.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fb37f79c1ff995e30d8891a0efe29ffe64d638a3dd5968c27a8e31363c14af6
-  data.tar.gz: 698761793f4c21b60d6cf99524230b039bab1bedf5c247fe10970487278f290f
+  metadata.gz: 9a0063f65dcbef1241a6a3c5833985d900ec665e136ca644335b9b14b8bdb153
+  data.tar.gz: 6c483db58e479281a16c09477699081a21ff3110c698d712ac8156769c795f5e
 SHA512:
-  metadata.gz: c02b5806633a061e286f0f6b4bd93fe8c0d4a82308d7f8c0b5939b9823aeca9c0c4a38200fe241fac608900499e813dced8eec9f2d9a490d7ec42d0735fd7554
-  data.tar.gz: 80322343ae8247133b175e267206a9eeaf26868918ac52b71d06702ba98b946e06b69a0d2f09842fb8ff285bcaad25e566da7747cf007f69217432b8fedff170
+  metadata.gz: 95d2907344606615a4947fc6c2e9046d557712f14e52b6e546be9d72ea47c86d1d1e60fcd11ab4a08d9182a22f8ee92ee42606a31d025600d6b8e44af6e65560
+  data.tar.gz: eb411a032c23bae788deef5da6e2b88b52675d0f52eed9a0d418ef552655779459f03596b4133d75bc6469de40227ba82aa55ba3e838f294244519b7e63d4e70

data/benchmark/benchmark_constants.rb

@@ -0,0 +1,11 @@
+#
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'benchmark_types'
+
+module ThriftBenchmark
+end

data/benchmark/benchmark_service.rb

@@ -0,0 +1,152 @@
+#
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'benchmark_types'
+
+module ThriftBenchmark
+  module BenchmarkService
+    SERVICE = 'BenchmarkService'.freeze
+    NAMESPACE = ''.freeze
+
+    LEGACY_ANNOTATIONS = {
+    }.freeze
+
+    STRUCTURED_ANNOTATIONS = [
+    ].freeze
+
+    # HELPER FUNCTIONS AND STRUCTURES
+
+    class Fibonacci_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+
+      NAME = 'fibonacci_args'.freeze
+      NAMESPACE = ''.freeze
+
+      LEGACY_ANNOTATIONS = {
+      }.freeze
+
+      STRUCTURED_ANNOTATIONS = [
+      ].freeze
+
+      THRIFT_FIELD_INDEX_N = 1
+
+      THRIFT_FIELD_N_LEGACY_ANNOTATIONS = {
+      }.freeze
+
+      THRIFT_FIELD_N_STRUCTURED_ANNOTATIONS = [
+      ].freeze
+
+      FIELDS = {
+        THRIFT_FIELD_INDEX_N => {type: ::Thrift::Types::BYTE, name: 'n', legacy_annotations: THRIFT_FIELD_N_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_N_STRUCTURED_ANNOTATIONS}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+      ::Thrift.register_struct_type self
+    end
+
+    class Fibonacci_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+
+      NAME = 'fibonacci_result'.freeze
+      NAMESPACE = ''.freeze
+
+      LEGACY_ANNOTATIONS = {
+      }.freeze
+
+      STRUCTURED_ANNOTATIONS = [
+      ].freeze
+
+      THRIFT_FIELD_INDEX_SUCCESS = 0
+
+      THRIFT_FIELD_SUCCESS_LEGACY_ANNOTATIONS = {
+      }.freeze
+
+      THRIFT_FIELD_SUCCESS_STRUCTURED_ANNOTATIONS = [
+      ].freeze
+
+      FIELDS = {
+        THRIFT_FIELD_INDEX_SUCCESS => {type: ::Thrift::Types::I32, name: 'success', legacy_annotations: THRIFT_FIELD_SUCCESS_LEGACY_ANNOTATIONS, structured_annotations: THRIFT_FIELD_SUCCESS_STRUCTURED_ANNOTATIONS}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+      ::Thrift.register_struct_type self
+    end
+
+    class Client
+      def initialize(client)
+        @client = ::Thrift.build_client(client)
+      end
+
+      def self.from_provider(provider)
+        Client.new(provider.build(NAMESPACE, SERVICE))
+      end
+
+      def fibonacci(n)
+        result = @client.call_binary(
+          'fibonacci',
+          Fibonacci_args.new(n: n),
+          Fibonacci_result
+        )
+
+        return result.success unless result.success.nil?
+        raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'fibonacci failed: unknown result')
+        result
+      end
+
+    end
+
+    class Processor
+      include ::Thrift::Processor
+
+      def self.from_provider(handler, provider)
+        provider.build(NAMESPACE, SERVICE, Processor, handler)
+      end
+
+      THRIFT_METHOD_FIBONACCI_LEGACY_ANNOTATIONS = {
+      }.freeze
+
+      THRIFT_METHOD_FIBONACCI_STRUCTURED_ANNOTATIONS = [
+      ].freeze
+
+      METHODS = {
+        'fibonacci' => { args_klass: Fibonacci_args, result_klass: Fibonacci_result, oneway: false, legacy_annotations: THRIFT_METHOD_FIBONACCI_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_FIBONACCI_STRUCTURED_ANNOTATIONS},
+      }.freeze
+
+      def execute_fibonacci(args)
+        result = Fibonacci_result.new()
+
+        result.success = @handler.fibonacci(args.n)
+        
+        result
+      end
+
+      def process_fibonacci(seqid, iprot, oprot)
+        args = read_args(iprot, Fibonacci_args)
+        result = @middleware.handle_binary('fibonacci', args) do |args|
+          execute_fibonacci(args)
+        end
+
+        write_result(result, oprot, 'fibonacci', seqid)
+      end
+
+    end
+
+    ::Thrift.register_service_type(self)
+
+  end
+
+end

data/benchmark/benchmark_types.rb

@@ -0,0 +1,10 @@
+#
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+
+module ThriftBenchmark
+end

data/ext/struct.c

@@ -290,7 +290,7 @@ static void write_container(int ttype, VALUE field_info, VALUE value, VALUE prot
 
     if (TYPE(value) == T_ARRAY) {
       items = value;
-    } else {        
+    } else {
       if (rb_cSet == CLASS_OF(value)) {
         items = rb_funcall(value, entries_method_id, 0);
       } else {
@@ -670,6 +670,10 @@ static VALUE rb_thrift_union_write(VALUE self, VALUE protocol) {
 
   VALUE field_info = rb_hash_aref(struct_fields, field_id);
 
+  if(NIL_P(field_info)) {
+    rb_raise(rb_eRuntimeError, "set_field is not valid for this union!");
+  }
+
   VALUE ttype_value = rb_hash_aref(field_info, type_sym);
   int ttype = FIX2INT(ttype_value);
 

data/lib/thrift/base_stream.rb

@@ -0,0 +1,85 @@
+module Thrift
+  class TBaseStream
+    def initialize(iprot, oprot, name, seqid)
+      @iprot = iprot
+      @oprot = oprot
+      @name = name
+      @seqid = seqid
+      @closed = false
+      @ready = false
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+    end
+
+    def ready
+      @ready = true
+      @cond.broadcast
+    end
+
+    protected
+
+    def wait_ready
+      return if @ready || @closed
+
+      @mutex.synchronize do
+        loop do
+          return if @ready || @closed
+
+          @cond.wait(@mutex)
+        end
+      end
+    end
+
+    def read_message_begin
+      name, mtype, seqid = @iprot.read_message_begin
+
+      raise ApplicationException.new(
+        ApplicationException::BAD_SEQUENCE_ID,
+        'out of seq'
+      ) if seqid != @seqid
+
+
+      raise ApplicationException.new(
+        ApplicationException::WRONG_METHOD_NAME,
+        'wrong method name'
+      ) if !name.nil? && name != @name
+
+      mtype
+    end
+
+    def read_shell
+      mtype = read_message_begin
+      @iprot.read_message_end
+
+      mtype
+    end
+
+    def write_unlocked(mtype, msg)
+      @oprot.write_message_begin(@name, mtype, @seqid)
+      msg.write(@oprot) if msg
+      @oprot.write_message_end
+      @oprot.trans.flush
+    end
+
+    def write(mtype, msg)
+      @mutex.synchronize do
+        write_unlocked(mtype, msg) unless @closed
+      end
+    end
+
+    def write_shell_unlocked(mtype)
+      write_unlocked(mtype, nil) unless @closed
+    end
+
+    def write_shell(mtype)
+      write(mtype, nil)
+    end
+
+    def mark_as_closed
+      @mutex.synchronize do
+        @closed = true
+        @cond.broadcast
+      end
+    end
+  end
+end

data/lib/thrift/bidi_stream.rb

@@ -0,0 +1,183 @@
+module Thrift
+  class TBidiInboundStream
+    def initialize(bidi_stream)
+      @bidi_stream = bidi_stream
+    end
+
+    def receive
+      @bidi_stream.receive
+    end
+
+    def close
+      @bidi_stream.inbound_close
+    end
+  end
+
+  class TBidiOutboundStream
+    def initialize(bidi_stream)
+      @bidi_stream = bidi_stream
+    end
+
+    def send(msg)
+      @bidi_stream.send(msg)
+    end
+
+    def close
+      @bidi_stream.outbound_close
+    end
+  end
+
+  class TBidiStream < TBaseStream
+    def initialize(iprot, oprot, name, seqid, inbound_klass, outbound_klass, inbound_message_type, outbound_message_type, unlock = nil)
+      @inbound_message_type = inbound_message_type
+      @outbound_message_type = outbound_message_type
+      @inbound_klass = inbound_klass
+      @outbound_klass = outbound_klass
+      @inbound_closed = false
+      @outbound_closed = false
+      @message_queue = Queue.new
+      @unlock = unlock
+      @closing_inbound = false
+      @closing_outbound = false
+      super(iprot, oprot, name, seqid)
+    end
+
+    def ready
+      Thread.new { background_read }
+      super
+    end
+
+    def inbound_close
+      wait_ready
+
+      @mutex.synchronize do
+        return if @closed || @inbbound_closed
+
+        @closing_inbound = true
+        write_shell_unlocked @inbound_message_type + 1
+
+        loop do
+          return if @closed || @inbound_closed
+
+          @cond.wait(@mutex)
+        end
+      end
+    end
+
+    def outbound_close
+      wait_ready
+
+      @mutex.synchronize do
+        return if @closed || @outbound_closed
+
+        @closing_outbound = true
+        write_shell_unlocked @outbound_message_type + 1
+
+        loop do
+          return nil if @closed || @outbound_closed
+
+          @cond.wait(@mutex)
+        end
+      end
+    end
+
+    def receive
+      raise EOFError if @closed || @inbound_closed
+
+      msg = @message_queue.pop
+
+      raise EOFError unless msg
+
+      msg.arg
+    end
+
+    def send(msg)
+      raise EOFError if @closed || @outbound_closed
+
+      unless @oprot.trans.open?
+        mark_as_closed
+        raise EOFError
+      end
+
+      wait_ready
+
+      write @outbound_message_type, @outbound_klass.new(arg: msg)
+    end
+
+    def close
+      mark_as_closed
+    end
+
+    private
+
+    def read_message
+      msg = @inbound_klass.new
+      msg.read(@iprot)
+      @iprot.read_message_end
+
+      @message_queue << msg unless @inbound_closed
+    end
+
+    def cleanup_inbound
+      @mutex.synchronize do
+        @inbound_closed = true
+        @message_queue.close unless @message_queue.closed?
+        @cond.broadcast
+      end
+    end
+
+    def cleanup_outbound
+      @mutex.synchronize do
+        @outbound_closed = true
+        @cond.broadcast
+      end
+    end
+
+    def background_read
+      loop do
+        begin
+          mtype = read_message_begin
+
+          case mtype
+          when @inbound_message_type
+            read_message
+          when @inbound_message_type + 1
+            @mutex.synchronize do
+              if !@inbound_closed && !@closing_inbound
+                write_shell_unlocked @inbound_message_type + 2
+              end
+            end
+
+            cleanup_inbound
+          when @inbound_message_type + 2
+            cleanup_inbound
+          when @outbound_message_type + 1
+            @mutex.synchronize do
+              if !@outbound_closed && !@closing_outbound
+                write_shell_unlocked @outbound_message_type + 2
+              end
+            end
+            cleanup_outbound
+          when @outbound_message_type + 2
+            cleanup_outbound
+          end
+        rescue Exception => e
+          mark_as_closed
+          @message_queue.close unless @message_queue.closed?
+          @cond.broadcast
+        end
+
+        if @outbound_closed && @inbound_closed
+          @closed = true
+          @cond.broadcast
+        end
+
+        if @closed
+          @unlock&.call
+          @cond.broadcast
+          return
+        end
+      end
+    end
+  end
+end

data/lib/thrift/client.rb

@@ -24,27 +24,16 @@ module Thrift
       @iprot = iprot
       @oprot = oprot || iprot
       @seqid = 0
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @ready = true
     end
 
     def send_message(name, args_class, args = {})
       @seqid += 1
       @oprot.write_message_begin(name, MessageTypes::CALL, @seqid)
-      send_message_args(args_class, args)
-    end
-
-    def send_oneway_message(name, args_class, args = {})
-      @seqid += 1
-      @oprot.write_message_begin(name, MessageTypes::ONEWAY, @seqid)
-      send_message_args(args_class, args)
-    end
-
-    def send_message_args(args_class, args)
       data = args_class.new
-
-      args.each do |k, v|
-        data.send("#{k.to_s}=", v)
-      end
-
+      args.each { |k, v| data.send("#{k}=", v) }
       send_message_instance(data)
     end
 
@@ -98,15 +87,93 @@ module Thrift
     include Client
 
     def call_unary(name, req)
-      @oprot.write_message_begin(name, Thrift::MessageTypes::ONEWAY, @seqid)
-      send_message_instance(req)
+      @mutex.synchronize do
+        @cond.wait(@mutex) until @ready
+
+        @seqid += 1
+        @oprot.write_message_begin(name, Thrift::MessageTypes::ONEWAY, @seqid)
+        send_message_instance(req)
+      end
     end
 
     def call_binary(name, req, resp_klass)
+      @mutex.synchronize do
+        @cond.wait(@mutex) until @ready
+
+        rpc_call(name, req, resp_klass)
+      end
+    end
+
+    def stream_client(name, req, resp_klass, sink_klass)
+      resp = stream_call(name, req, resp_klass)
+      stream = TOutboundStream.new(
+        @iprot, @oprot, name, @seqid, sink_klass,
+        MessageTypes::CLIENT_STREAM_MESSAGE,
+        method(:finish_call)
+      )
+
+      stream.ready
+
+      [resp, stream]
+    end
+
+    def stream_server(name, req, resp_klass, sink_klass)
+      resp = stream_call(name, req, resp_klass)
+      stream = TInboundStream.new(
+        @iprot, @oprot, name, @seqid, sink_klass,
+        MessageTypes::SERVER_STREAM_MESSAGE,
+        method(:finish_call)
+      )
+
+      stream.ready
+
+      [resp, stream]
+    end
+
+    def stream_bidi(name, req, resp_klass, stream_klass, sink_klass)
+      resp = stream_call(name, req, resp_klass)
+      stream = TBidiStream.new(
+        @iprot, @oprot, name, @seqid,
+        stream_klass, sink_klass,
+        MessageTypes::SERVER_STREAM_MESSAGE,
+        MessageTypes::CLIENT_STREAM_MESSAGE,
+        method(:finish_call)
+      )
+
+      stream.ready
+
+      [
+        resp,
+        TBidiInboundStream.new(stream),
+        TBidiOutboundStream.new(stream)
+      ]
+    end
+
+    private
+
+    def stream_call(name, req, resp_klass)
+      @mutex.synchronize do
+        @cond.wait(@mutex) until @ready
+
+        @ready = false
+      end
+
+      rpc_call(name, req, resp_klass)
+    end
+
+    def rpc_call(name, req, resp_klass)
+      @seqid += 1
       @oprot.write_message_begin(name, Thrift::MessageTypes::CALL, @seqid)
       send_message_instance(req)
       receive_message(resp_klass)
     end
+
+    def finish_call
+      @mutex.synchronize do
+        @ready = true
+        @cond.signal
+      end
+    end
   end
 
   class << self

data/lib/thrift/definition.rb

@@ -15,10 +15,14 @@ module Thrift
     end
 
     def structured_annotations
+      return [] unless @klass.const_defined? :STRUCTURED_ANNOTATIONS
+
       @klass::STRUCTURED_ANNOTATIONS
     end
 
     def legacy_annotations
+      return {} unless @klass.const_defined? :LEGACY_ANNOTATIONS
+
       @klass::LEGACY_ANNOTATIONS
     end
 

data/lib/thrift/inbound_stream.rb

@@ -0,0 +1,72 @@
+module Thrift
+  class TInboundStream < TBaseStream
+    def initialize(iprot, oprot, name, seqid, klass, message_type, unlock = nil)
+      @message_type = message_type
+      @klass = klass
+      @unlock = unlock
+      @closing = false
+      super(iprot, oprot, name, seqid)
+    end
+
+    def close
+      wait_ready
+
+      @mutex.synchronize do
+        return nil if @closed
+
+        begin
+          @closing = true
+          write_shell_unlocked @message_type + 1
+
+          loop do
+            mtype = read_message_begin
+
+            case mtype
+            when @message_type
+              @iprot.skip(Types::STRUCT)
+              @iprot.read_message_end
+            when @message_type + 2
+              @iprot.read_message_end
+              return
+            else
+              raise ApplicationException.new(
+                ApplicationException::INVALID_MESSAGE_TYPE,
+                'invalid message type'
+              )
+            end
+          end
+        ensure
+          @unlock&.call
+        end
+      end
+    end
+
+    def receive
+      wait_ready
+
+      @mutex.synchronize do
+        case read_message_begin
+        when @message_type
+          res = @klass.new
+          res.read(@iprot)
+          @iprot.read_message_end
+
+          return res.arg
+        when @message_type + 1
+          @iprot.read_message_end
+          write_shell_unlocked @message_type + 2 unless @closing
+          @closed = true
+          @cond.broadcast
+          @unlock&.call
+
+          raise EOFError
+        else
+          raise ApplicationException.new(
+            ApplicationException::INVALID_MESSAGE_TYPE,
+            'invalid message type'
+          )
+        end
+      end
+    end
+  end
+end