splitclient-rb 7.2.1-java → 7.2.3.pre.rc2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f3496e0c2b63f8688a75ef1ad4213c753ca37c0
-  data.tar.gz: 1a05822a6b9c7150f8d80a5e6dd24c6b79f1b024
+  metadata.gz: 287f7f79723676d979a36e981d7aa7872eb10b77
+  data.tar.gz: 963b3062d4197614d6d36e48fb9fdd680c41bc34
 SHA512:
-  metadata.gz: 3a1709eda2a0b7c5aa449274ed3d1fb2f22f99f936eb7fb555417d60119f81f419359eaad023dd72b78c48820226d7e32bc50dbaad89b2681c6b111be440cbdf
-  data.tar.gz: 2a09f9d13f35a240f7ac0c40225252834a3ec5fc400b5ac68d37e1cb0da0c8dbdd7c951cd429f629e76d7701b123887327768aeba7225f9d67fd76f937ae1941
+  metadata.gz: ee086221eb257722cd337b0c174271c926b249acfe60d96734a8b7da0314439c2cf44ada73df7a08dc19397f5bac8a5cf682dcf814767d343db5ad794793bbfb
+  data.tar.gz: 4fdefe428f8d4cfda3577d3fe79a0bc25bab342154b616b99cad81ed19b52e905269abae642f31ba188dbc5958caac002eae3948eb2f4dc5f19449bc46698d79

data/.rubocop.yml

@@ -10,6 +10,9 @@ Metrics/MethodLength:
 Metrics/ClassLength:
   Max: 150
 
+Metrics/CyclomaticComplexity:
+  Max: 8
+
 Metrics/LineLength:
   Max: 130
   Exclude:

data/CHANGES.txt

@@ -1,5 +1,8 @@
 CHANGES
 
+7.2.2 (Dec 18, 2020)
+- Fixed issue: undefined local variable or method post_impressions_count
+
 7.2.1 (Oct 23, 2020)
 - Updated redis dependency to >= 4.2.2.
 - Updated ably error handling. 

data/lib/splitclient-rb/cache/fetchers/segment_fetcher.rb

@@ -27,14 +27,22 @@ module SplitIoClient
           end
         end
 
+        def fetch_segments_if_not_exists(names)
+          names.each do |name|
+            change_number = @segments_repository.get_change_number(name)
+
+            fetch_segment(name) if change_number == -1
+          end
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
+
         def fetch_segment(name)
           @semaphore.synchronize do
             segments_api.fetch_segments_by_names([name])
-            true
           end
         rescue StandardError => error
           @config.log_found_exception(__method__.to_s, error)
-          false
         end
 
         def fetch_segments

data/lib/splitclient-rb/cache/fetchers/split_fetcher.rb

@@ -41,11 +41,11 @@ module SplitIoClient
             @config.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if @config.debug_enabled
 
             @sdk_blocker.splits_ready!
-            true
+
+            data[:segment_names]
           end
         rescue StandardError => error
           @config.log_found_exception(__method__.to_s, error)
-          false
         end
 
         def stop_splits_thread

data/lib/splitclient-rb/cache/senders/impressions_count_sender.rb

@@ -40,32 +40,32 @@ module SplitIoClient
               @config.logger.info('Posting impressions count due to shutdown')
             end
           end
+        end
 
-          def post_impressions_count
-            @impressions_api.post_count(formatter(@impression_counter.pop_all))
-          rescue StandardError => error
-            @config.log_found_exception(__method__.to_s, error)
-          end
-
-          def formatter(counts)
-            return if counts.empty?
+        def post_impressions_count
+          @impressions_api.post_count(formatter(@impression_counter.pop_all))
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
+        end
 
-            formated_counts = {pf: []}
+        def formatter(counts)
+          return if counts.empty?
 
-            counts.each do |key, value|              
-              key_splited = key.split('::')
-              
-              formated_counts[:pf] << {
-                f: key_splited[0].to_s, # feature name
-                m: key_splited[1].to_i, # time frame
-                rc: value # count
-              }
-            end
+          formated_counts = {pf: []}
 
-            formated_counts
-          rescue StandardError => error
-            @config.log_found_exception(__method__.to_s, error)
+          counts.each do |key, value|              
+            key_splited = key.split('::')
+            
+            formated_counts[:pf] << {
+              f: key_splited[0].to_s, # feature name
+              m: key_splited[1].to_i, # time frame
+              rc: value # count
+            }
           end
+
+          formated_counts
+        rescue StandardError => error
+          @config.log_found_exception(__method__.to_s, error)
         end
       end
     end

data/lib/splitclient-rb/constants.rb

@@ -6,5 +6,10 @@ class SplitIoClient::Constants
   CONTROL_SEC = 'control_sec'
   OCCUPANCY_CHANNEL_PREFIX = '[?occupancy=metrics.publishers]'
   FETCH_BACK_OFF_BASE_RETRIES = 1
+  PUSH_CONNECTED = 'PUSH_CONNECTED'
+  PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
+  PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
+  PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'
+  PUSH_SUBSYSTEM_READY = 'PUSH_SUBSYSTEM_READY'
+  PUSH_SUBSYSTEM_OFF = 'PUSH_SUBSYSTEM_OFF'
 end
-  

data/lib/splitclient-rb/engine/push_manager.rb

@@ -19,12 +19,13 @@ module SplitIoClient
         if response[:push_enabled] && @sse_handler.start(response[:token], response[:channels])
           schedule_next_token_refresh(response[:exp])
           @back_off.reset
-          return
+          return true
         end
 
         stop_sse
 
         schedule_next_token_refresh(@back_off.interval) if response[:retry]
+        false
       rescue StandardError => e
         @config.logger.error("start_sse: #{e.inspect}")
       end

data/lib/splitclient-rb/engine/sync_manager.rb

@@ -11,8 +11,7 @@ module SplitIoClient
       )
         @synchronizer = synchronizer
         notification_manager_keeper = SplitIoClient::SSE::NotificationManagerKeeper.new(config) do |manager|
-          manager.on_occupancy { |publisher_available| process_occupancy(publisher_available) }
-          manager.on_push_shutdown { process_push_shutdown }
+          manager.on_action { |action| process_action(action) }
         end
         @sse_handler = SplitIoClient::SSE::SSEHandler.new(
           config,
@@ -21,8 +20,7 @@ module SplitIoClient
           repositories[:segments],
           notification_manager_keeper
         ) do |handler|
-          handler.on_connected { process_connected }
-          handler.on_disconnect { |reconnect| process_disconnect(reconnect) }
+          handler.on_action { |action| process_action(action) }
         end
 
         @push_manager = PushManager.new(config, @sse_handler, api_key)
@@ -44,10 +42,10 @@ module SplitIoClient
       # Starts tasks if stream is enabled.
       def start_stream
         @config.logger.debug('Starting push mode ...')
-        stream_start_thread
+        sync_all_thread
         @synchronizer.start_periodic_data_recording
 
-        stream_start_sse_thread
+        start_sse_connection_thread
       end
 
       def start_poll
@@ -59,23 +57,24 @@ module SplitIoClient
       end
 
       # Starts thread which fetch splits and segments once and trigger task to periodic data recording.
-      def stream_start_thread
+      def sync_all_thread
         @config.threads[:sync_manager_start_stream] = Thread.new do
           begin
             @synchronizer.sync_all
           rescue StandardError => e
-            @config.logger.error("stream_start_thread error : #{e.inspect}")
+            @config.logger.error("sync_all_thread error : #{e.inspect}")
           end
         end
       end
 
       # Starts thread which connect to sse and after that fetch splits and segments once.
-      def stream_start_sse_thread
+      def start_sse_connection_thread
         @config.threads[:sync_manager_start_sse] = Thread.new do
           begin
-            @push_manager.start_sse
+            connected = @push_manager.start_sse
+            @synchronizer.start_periodic_fetch unless connected
           rescue StandardError => e
-            @config.logger.error("stream_start_sse_thread error : #{e.inspect}")
+            @config.logger.error("start_sse_connection_thread error : #{e.inspect}")
           end
         end
       end
@@ -84,6 +83,46 @@ module SplitIoClient
         PhusionPassenger.on_event(:starting_worker_process) { |forked| start_stream if forked }
       end
 
+      def process_action(action)
+        case action
+        when Constants::PUSH_CONNECTED
+          process_connected
+        when Constants::PUSH_RETRYABLE_ERROR
+          process_disconnect(true)
+        when Constants::PUSH_NONRETRYABLE_ERROR
+          process_disconnect(false)
+        when Constants::PUSH_SUBSYSTEM_DOWN
+          process_subsystem_down
+        when Constants::PUSH_SUBSYSTEM_READY
+          process_subsystem_ready
+        when Constants::PUSH_SUBSYSTEM_OFF
+          process_push_shutdown
+        else
+          @config.logger.debug('Incorrect action type.')
+        end
+      rescue StandardError => e
+        @config.logger.error("process_action error: #{e.inspect}")
+      end
+
+      def process_subsystem_ready
+        @synchronizer.stop_periodic_fetch
+        @synchronizer.sync_all
+        @sse_handler.start_workers
+      end
+
+      def process_subsystem_down
+        @sse_handler.stop_workers
+        @synchronizer.start_periodic_fetch
+      end
+
+      def process_push_shutdown
+        @push_manager.stop_sse
+        @sse_handler.stop_workers
+        @synchronizer.start_periodic_fetch
+      rescue StandardError => e
+        @config.logger.error("process_push_shutdown error: #{e.inspect}")
+      end
+
       def process_connected
         if @sse_connected.value
           @config.logger.debug('Streaming already connected.')
@@ -115,28 +154,6 @@ module SplitIoClient
       rescue StandardError => e
         @config.logger.error("process_disconnect error: #{e.inspect}")
       end
-
-      def process_occupancy(push_enable)
-        if push_enable
-          @synchronizer.stop_periodic_fetch
-          @synchronizer.sync_all
-          @sse_handler.start_workers
-          return
-        end
-
-        @sse_handler.stop_workers
-        @synchronizer.start_periodic_fetch
-      rescue StandardError => e
-        @config.logger.error("process_occupancy error: #{e.inspect}")
-      end
-
-      def process_push_shutdown
-        @push_manager.stop_sse
-        @sse_handler.stop_workers
-        @synchronizer.start_periodic_fetch
-      rescue StandardError => e
-        @config.logger.error("process_push_shutdown error: #{e.inspect}")
-      end
     end
   end
 end

data/lib/splitclient-rb/engine/synchronizer.rb

@@ -30,7 +30,7 @@ module SplitIoClient
       def sync_all
         @config.threads[:sync_all_thread] = Thread.new do
           @config.logger.debug('Synchronizing Splits and Segments ...') if @config.debug_enabled
-          fetch_splits
+          @split_fetcher.fetch_splits
           fetch_segments
         end
       end
@@ -53,21 +53,12 @@ module SplitIoClient
       end
 
       def fetch_splits
-        back_off = SplitIoClient::SSE::EventSource::BackOff.new(SplitIoClient::Constants::FETCH_BACK_OFF_BASE_RETRIES, 1)
-        loop do
-          break if @split_fetcher.fetch_splits
-
-          sleep(back_off.interval)
-        end
+        segment_names = @split_fetcher.fetch_splits
+        @segment_fetcher.fetch_segments_if_not_exists(segment_names) unless segment_names.empty?
       end
 
       def fetch_segment(name)
-        back_off = SplitIoClient::SSE::EventSource::BackOff.new(SplitIoClient::Constants::FETCH_BACK_OFF_BASE_RETRIES, 1)
-        loop do
-          break if @segment_fetcher.fetch_segment(name)
-
-          sleep(back_off.interval)
-        end
+        @segment_fetcher.fetch_segment(name)
       end
 
       private

data/lib/splitclient-rb/sse/event_source/client.rb

@@ -9,6 +9,7 @@ module SplitIoClient
       class Client
         DEFAULT_READ_TIMEOUT = 70
         CONNECT_TIMEOUT = 30_000
+        OK_CODE = 200
         KEEP_ALIVE_RESPONSE = "c\r\n:keepalive\n\n\r\n".freeze
         ERROR_EVENT_TYPE = 'error'.freeze
 
@@ -16,9 +17,10 @@ module SplitIoClient
           @config = config
           @read_timeout = read_timeout
           @connected = Concurrent::AtomicBoolean.new(false)
+          @first_event = Concurrent::AtomicBoolean.new(true)
           @socket = nil
           @event_parser = SSE::EventSource::EventParser.new(config)
-          @on = { event: ->(_) {}, connected: ->(_) {}, disconnect: ->(_) {} }
+          @on = { event: ->(_) {}, action: ->(_) {} }
 
           yield self if block_given?
         end
@@ -27,16 +29,12 @@ module SplitIoClient
           @on[:event] = action
         end
 
-        def on_connected(&action)
-          @on[:connected] = action
+        def on_action(&action)
+          @on[:action] = action
         end
 
-        def on_disconnect(&action)
-          @on[:disconnect] = action
-        end
-
-        def close(reconnect = false)
-          dispatch_disconnect(reconnect)
+        def close(action = Constants::PUSH_NONRETRYABLE_ERROR)
+          dispatch_action(action)
           @connected.make_false
           SplitIoClient::Helpers::ThreadHelper.stop(:connect_stream, @config)
           @socket&.close
@@ -45,6 +43,11 @@ module SplitIoClient
         end
 
         def start(url)
+          if connected?
+            @config.logger.debug('SSEClient already running.')
+            return true
+          end
+
           @uri = URI(url)
           latch = Concurrent::CountDownLatch.new(1)
 
@@ -72,16 +75,18 @@ module SplitIoClient
         end
 
         def connect_stream(latch)
-          socket_write(latch)
+          socket_write
 
-          while @connected.value
+          while connected? || @first_event.value
             begin
               partial_data = @socket.readpartial(10_000, timeout: @read_timeout)
 
+              read_first_event(partial_data, latch)
+
               raise 'eof exception' if partial_data == :eof
             rescue StandardError => e
               @config.logger.error('Error reading partial data: ' + e.inspect) if @config.debug_enabled
-              close(true) # close conexion & reconnect
+              close(Constants::PUSH_RETRYABLE_ERROR)
               return
             end
 
@@ -89,14 +94,31 @@ module SplitIoClient
           end
         end
 
-        def socket_write(latch)
+        def socket_write
+          @first_event.make_true
           @socket = socket_connect
           @socket.write(build_request(@uri))
-          dispatch_connected
         rescue StandardError => e
           @config.logger.error("Error during connecting to #{@uri.host}. Error: #{e.inspect}")
-          close
-        ensure
+          close(Constants::PUSH_NONRETRYABLE_ERROR)
+        end
+
+        def read_first_event(data, latch)
+          return unless @first_event.value
+
+          response_code = @event_parser.first_event(data)
+          @config.logger.debug("SSE client first event code: #{response_code}")
+
+          error_event = false
+          events = @event_parser.parse(data)
+          events.each { |e| error_event = true if e.event_type == ERROR_EVENT_TYPE }
+          @first_event.make_false
+
+          if response_code == OK_CODE && !error_event
+            @connected.make_true
+            dispatch_action(Constants::PUSH_CONNECTED)
+          end
+
           latch.count_down
         end
 
@@ -137,9 +159,9 @@ module SplitIoClient
         def dispatch_error(event)
           @config.logger.error("Event error: #{event.event_type}, #{event.data}")
           if event.data['code'] >= 40_140 && event.data['code'] <= 40_149
-            close(true) # close conexion & reconnect
+            close(Constants::PUSH_RETRYABLE_ERROR)
           elsif event.data['code'] >= 40_000 && event.data['code'] <= 49_999
-            close # close conexion
+            close(Constants::PUSH_NONRETRYABLE_ERROR)
           end
         end
 
@@ -148,15 +170,9 @@ module SplitIoClient
           @on[:event].call(event)
         end
 
-        def dispatch_connected
-          @connected.make_true
-          @config.logger.debug('Dispatching connected') if @config.debug_enabled
-          @on[:connected].call
-        end
-
-        def dispatch_disconnect(reconnect)
-          @config.logger.debug('Dispatching disconnect') if @config.debug_enabled
-          @on[:disconnect].call(reconnect)
+        def dispatch_action(action)
+          @config.logger.debug("Dispatching action: #{action}") if @config.debug_enabled
+          @on[:action].call(action)
         end
       end
     end

data/lib/splitclient-rb/sse/event_source/event_parser.rb

@@ -4,6 +4,8 @@ module SplitIoClient
   module SSE
     module EventSource
       class EventParser
+        BAD_REQUEST_CODE = 400
+
         def initialize(config)
           @config = config
         end
@@ -27,10 +29,17 @@ module SplitIoClient
 
           events
         rescue StandardError => e
-          @config.logger.error("Error during parsing a event: #{e.inspect}")
+          @config.logger.debug("Error during parsing a event: #{e.inspect}")
           []
         end
 
+        def first_event(raw_data)
+          raw_data.split("\n")[0].split(' ')[1].to_i
+        rescue StandardError => e
+          @config.logger.debug("Error parsing first event: #{e.inspect}")
+          BAD_REQUEST_CODE
+        end
+
         private
 
         def parse_event_data(data, type)

data/lib/splitclient-rb/sse/notification_manager_keeper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'concurrent/atomics'
+require 'concurrent'
 
 module SplitIoClient
   module SSE
@@ -8,7 +8,9 @@ module SplitIoClient
       def initialize(config)
         @config = config
         @publisher_available = Concurrent::AtomicBoolean.new(true)
-        @on = { occupancy: ->(_) {}, push_shutdown: ->(_) {} }
+        @publishers_pri = Concurrent::AtomicFixnum.new
+        @publishers_sec = Concurrent::AtomicFixnum.new
+        @on = { action: ->(_) {} }
 
         yield self if block_given?
       end
@@ -16,19 +18,15 @@ module SplitIoClient
       def handle_incoming_occupancy_event(event)
         if event.data['type'] == 'CONTROL'
           process_event_control(event.data['controlType'])
-        elsif event.channel == SplitIoClient::Constants::CONTROL_PRI
-          process_event_occupancy(event.data['metrics']['publishers'])
+        else
+          process_event_occupancy(event.channel, event.data['metrics']['publishers'])
         end
       rescue StandardError => e
         @config.logger.error(e)
       end
 
-      def on_occupancy(&action)
-        @on[:occupancy] = action
-      end
-
-      def on_push_shutdown(&action)
-        @on[:push_shutdown] = action
+      def on_action(&action)
+        @on[:action] = action
       end
 
       private
@@ -36,35 +34,42 @@ module SplitIoClient
       def process_event_control(type)
         case type
         when 'STREAMING_PAUSED'
-          dispatch_occupancy_event(false)
+          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
         when 'STREAMING_RESUMED'
-          dispatch_occupancy_event(true) if @publisher_available.value
+          dispatch_action(Constants::PUSH_SUBSYSTEM_READY) if @publisher_available.value
         when 'STREAMING_DISABLED'
-          dispatch_push_shutdown
+          dispatch_action(Constants::PUSH_SUBSYSTEM_OFF)
         else
           @config.logger.error("Incorrect event type: #{incoming_notification}")
         end
       end
 
-      def process_event_occupancy(publishers)
-        @config.logger.debug("Occupancy process event with #{publishers} publishers") if @config.debug_enabled
-        if publishers <= 0 && @publisher_available.value
+      def process_event_occupancy(channel, publishers)
+        @config.logger.debug("Processed occupancy event with #{publishers} publishers. Channel: #{channel}")
+
+        update_publishers(channel, publishers)
+
+        if !are_publishers_available? && @publisher_available.value
           @publisher_available.make_false
-          dispatch_occupancy_event(false)
-        elsif publishers >= 1 && !@publisher_available.value
+          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
+        elsif are_publishers_available? && !@publisher_available.value
           @publisher_available.make_true
-          dispatch_occupancy_event(true)
+          dispatch_action(Constants::PUSH_SUBSYSTEM_READY)
         end
       end
 
-      def dispatch_occupancy_event(push_enable)
-        @config.logger.debug("Dispatching occupancy event with publisher avaliable: #{push_enable}")
-        @on[:occupancy].call(push_enable)
+      def update_publishers(channel, publishers)
+        @publishers_pri.value = publishers if channel == Constants::CONTROL_PRI
+        @publishers_sec.value = publishers if channel == Constants::CONTROL_SEC
+      end
+
+      def are_publishers_available?
+        @publishers_pri.value.positive? || @publishers_sec.value.positive?
       end
 
-      def dispatch_push_shutdown
-        @config.logger.debug('Dispatching push shutdown')
-        @on[:push_shutdown].call
+      def dispatch_action(action)
+        @config.logger.debug("Dispatching action: #{action}")
+        @on[:action].call(action)
       end
     end
   end

data/lib/splitclient-rb/sse/sse_handler.rb

@@ -13,11 +13,10 @@ module SplitIoClient
         @notification_processor = SplitIoClient::SSE::NotificationProcessor.new(config, @splits_worker, @segments_worker)
         @sse_client = SSE::EventSource::Client.new(@config) do |client|
           client.on_event { |event| handle_incoming_message(event) }
-          client.on_connected { process_connected }
-          client.on_disconnect { |reconnect| process_disconnect(reconnect) }
+          client.on_action { |action| process_action(action) }
         end
 
-        @on = { connected: ->(_) {}, disconnect: ->(_) {} }
+        @on = { action: ->(_) {} }
 
         yield self if block_given?
       end
@@ -48,22 +47,14 @@ module SplitIoClient
         @segments_worker.stop
       end
 
-      def on_connected(&action)
-        @on[:connected] = action
-      end
-
-      def on_disconnect(&action)
-        @on[:disconnect] = action
-      end
-
-      def process_disconnect(reconnect)
-        @on[:disconnect].call(reconnect)
+      def on_action(&action)
+        @on[:action] = action
       end
 
       private
 
-      def process_connected
-        @on[:connected].call
+      def process_action(action)
+        @on[:action].call(action)
       end
 
       def handle_incoming_message(notification)

data/lib/splitclient-rb/sse/workers/segments_worker.rb

@@ -48,12 +48,13 @@ module SplitIoClient
         def perform
           while (item = @queue.pop)
             segment_name = item[:segment_name]
-            change_number = item[:change_number]
-            since = @segments_repository.get_change_number(segment_name)
+            cn = item[:change_number]
+            @config.logger.debug("SegmentsWorker change_number dequeue #{segment_name}, #{cn}")
 
-            unless since >= change_number
-              @config.logger.debug("SegmentsWorker fetch_segment with #{since}")
+            attempt = 0
+            while cn > @segments_repository.get_change_number(segment_name).to_i && attempt <= Workers::MAX_RETRIES_ALLOWED
               @synchronizer.fetch_segment(segment_name)
+              attempt += 1
             end
           end
         end

data/lib/splitclient-rb/sse/workers/splits_worker.rb

@@ -3,6 +3,8 @@
 module SplitIoClient
   module SSE
     module Workers
+      MAX_RETRIES_ALLOWED = 10
+
       class SplitsWorker
         def initialize(synchronizer, config, splits_repository)
           @synchronizer = synchronizer
@@ -59,11 +61,12 @@ module SplitIoClient
 
         def perform
           while (change_number = @queue.pop)
-            since = @splits_repository.get_change_number
+            @config.logger.debug("SplitsWorker change_number dequeue #{change_number}")
 
-            unless since.to_i >= change_number
-              @config.logger.debug("SplitsWorker fetch_splits with #{since}")
+            attempt = 0
+            while change_number > @splits_repository.get_change_number.to_i && attempt <= Workers::MAX_RETRIES_ALLOWED
               @synchronizer.fetch_splits
+              attempt += 1
             end
           end
         end

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '7.2.1'
+  VERSION = '7.2.3.pre.rc2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 7.2.1
+  version: 7.2.3.pre.rc2
 platform: java
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-23 00:00:00.000000000 Z
+date: 2021-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -450,9 +450,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project:
 rubygems_version: 2.6.14