upfluence-thrift 2.6.8 → 2.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 910b976b447406af13cf97d33ef26b0aa3d28cbbc90b6b8df8e5dfbdb7529026
-  data.tar.gz: a38f2536a472b778aef2083161e93bc973767c2a76ecbe139ecf63eda3d60565
+  metadata.gz: 9a0063f65dcbef1241a6a3c5833985d900ec665e136ca644335b9b14b8bdb153
+  data.tar.gz: 6c483db58e479281a16c09477699081a21ff3110c698d712ac8156769c795f5e
 SHA512:
-  metadata.gz: f70ad188a73e4113379a1f862ff7495b22bd1dd3a970e69326cc21d7cfb069834f7f63ce2b689d9bdf71a4b7033be54de90c8f78bf61eac3ed72519e9f675275
-  data.tar.gz: 5c41d9170f392877200e283da4a61b332db3c2669617f8ba3dd09fad50a914e4b0175be8271c5998047abc154f4f49d9035aa5f6d618b1768875c0e77733acf1
+  metadata.gz: 95d2907344606615a4947fc6c2e9046d557712f14e52b6e546be9d72ea47c86d1d1e60fcd11ab4a08d9182a22f8ee92ee42606a31d025600d6b8e44af6e65560
+  data.tar.gz: eb411a032c23bae788deef5da6e2b88b52675d0f52eed9a0d418ef552655779459f03596b4133d75bc6469de40227ba82aa55ba3e838f294244519b7e63d4e70

data/benchmark/{gen-rb/benchmark_constants.rb → benchmark_constants.rb}

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #

data/benchmark/{gen-rb/benchmark_service.rb → benchmark_service.rb}

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #
@@ -123,7 +123,7 @@ module ThriftBenchmark
       ].freeze
 
       METHODS = {
-        'fibonacci' => { args_klass: Fibonacci_args, oneway: false, legacy_annotations: THRIFT_METHOD_FIBONACCI_STRUCTURED_ANNOTATIONS, structured_annotations: THRIFT_METHOD_FIBONACCI_STRUCTURED_ANNOTATIONS},
+        '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)

data/benchmark/{gen-rb/benchmark_types.rb → benchmark_types.rb}

@@ -1,5 +1,5 @@
 #
-# Autogenerated by Thrift Compiler ()
+# Autogenerated by Thrift Compiler (v0.0.1-upfluence)
 #
 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 #

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/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

data/lib/thrift/middleware.rb

@@ -8,6 +8,18 @@ module Thrift
       def handle_unary(_mth, args = {},  &block)
         block.call(args)
       end
+
+      def handle_bidi_stream(_mth, args, istream, ostream, &block)
+        block.call(args, istream, ostream)
+      end
+
+      def handle_inbound_stream(_mth, args, istream, &block)
+        block.call(args, istream)
+      end
+
+      def handle_outbound_stream(_mth, args, ostream, &block)
+        block.call(args, ostream)
+      end
     end
 
     class MultiMiddleware
@@ -30,6 +42,36 @@ module Thrift
           end
         end.call(args)
       end
+
+      def handle_bidi_stream(_mth, args, istream, ostream, &block)
+        @middlewares.reverse.reduce(block) do |acc, m|
+          Proc.new do |args, istream, ostream|
+            m.handle_bidi_stream(mth, args, istream, ostream) do |args, istream, ostream|
+              acc.call(args, istream, ostream)
+            end
+          end
+        end.call(args, istream, ostream)
+      end
+
+      def handle_inbound_stream(_mth, args, istream, &block)
+        @middlewares.reverse.reduce(block) do |acc, m|
+          Proc.new do |args, istream|
+            m.handle_bidi_stream(mth, args, istream) do |args, istream|
+              acc.call(args, istream)
+            end
+          end
+        end.call(args, istream)
+      end
+
+      def handle_outbound_stream(_mth, args, ostream, &block)
+        @middlewares.reverse.reduce(block) do |acc, m|
+          Proc.new do |args, ostream|
+            m.handle_bidi_stream(mth, args, ostream) do |args, ostream|
+              acc.call(args, ostream)
+            end
+          end
+        end.call(args, ostream)
+      end
     end
 
     NOP_MIDDLEWARE = NopMiddleware.new

data/lib/thrift/outbound_stream.rb

@@ -0,0 +1,52 @@
+module Thrift
+  class TOutboundStream < TBaseStream
+    def initialize(iprot, oprot, name, seqid, klass, message_type, unlock = nil)
+      @message_type = message_type
+      @klass = klass
+      @unlock = unlock
+      super(iprot, oprot, name, seqid)
+    end
+
+    def ready
+      Thread.new { read_goaway }
+      super
+    end
+
+    def close
+      wait_ready
+
+      write_shell @message_type + 1
+
+      @mutex.synchronize do
+        loop do
+          @cond.wait(@mutex)
+
+          return nil if @closed
+        end
+      end
+    end
+
+    def send(arg)
+      raise EOFError if @closed
+
+      unless @oprot.trans.open?
+        mark_as_closed
+        raise EOFError
+      end
+
+      wait_ready
+      write @message_type, @klass.new(arg: arg)
+    end
+
+    private
+
+    def read_goaway
+      mtype = read_shell
+
+      write_shell @message_type + 2 if mtype == (@message_type + 1)
+    ensure
+      mark_as_closed
+      @unlock&.call
+    end
+  end
+end