istox 0.1.155.1 → 0.1.156

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    istox (0.1.155)
+    istox (0.1.156)
       amazing_print
       awesome_print
       binding_of_caller

data/lib/istox/helpers/bunny_boot.rb

@@ -56,6 +56,10 @@ module Istox
         ch
       end
 
+      def channel_confirm?(ch)
+        ch.using_publisher_confirmations?
+      end
+
       def exchange(eid)
         type = data[:exchanges][eid][:type]
         name = eid
@@ -254,29 +258,34 @@ module Istox
 
       def publish(e, message, options = {})
         eid = eid e
+        # By default:
+        # For persistence, if exchange is durable, persistent is enabled
+        # For mandatory. if channel is confirmed mode, mandatory is enabled
         persistent = e.durable?
-        mandatory = false
+        mandatory = channel_confirm? e.channel
+        options_dup = options.clone
+
         # Set Mandatory & Persistent flag for non-DLX and non-manual msg
-        unless %w[dlx manual].include? options[:type]
-          if options[:routing_key].present?
+        unless %w[dlx manual].include? options_dup[:type]
+          if options_dup[:routing_key].present?
             v1 = data['publish'][eid]
-            v1 = v1[options[:routing_key]] unless v1.nil?
-            persistent = v1['persistent'] unless v1.nil?
-            mandatory = v1['mandatory'] unless v1.nil?
+            v1 = v1[options_dup[:routing_key]] unless v1.nil? || v1[options_dup[:routing_key]].nil?
+            persistent = v1['persistent'] unless v1.nil? || v1['persistent'].nil?
+            mandatory = v1['mandatory'] unless v1.nil? || v1['mandatory'].nil?
           end
         end
-        options.merge!(persistent: persistent)
-        options.merge!(mandatory: mandatory)
+        options_dup.merge!(persistent: persistent)
+        options_dup.merge!(mandatory: mandatory)
         # message.merge!(locale: I18n.locale)
 
         publisher_interceptors.each do |interceptor|
-          interceptor.call(message, options)
+          interceptor.call(message, options_dup)
         end
 
         message = JSON.dump message
-        log.debug "Publish options are: #{options}"
+        log.debug "Publish options are: #{options_dup}"
         log.debug "Publish message payload #{message}"
-        e.publish(message, options)
+        e.publish(message, options_dup)
 
         options[:message_id]
       end

data/lib/istox/helpers/publisher.rb

@@ -104,7 +104,7 @@ module Istox
       def channel
         return @channel[Thread.current.object_id] if @channel.present? && @channel[Thread.current.object_id].present?
 
-        log.info "#{Thread.current.object_id} No channel yet, create 2 channels confirm-mode and non-confirm-mode ... ..."
+        log.info "Thread<#{Thread.current.object_id}> No channel yet, create 3 channels confirm-mode and non-confirm-mode ... ..."
         @channel = Hash.new if @channel.nil?
         @channel[Thread.current.object_id] = Hash.new
         @channel[Thread.current.object_id]['confirm-0'] = ::Istox::BunnyBoot.channel(connection, confirm: true)
@@ -174,38 +174,61 @@ module Istox
         # when an unroutable message is returned, the BasicReturn is fired first and then an ack is sent, firing the BasicAck second.
         # So if the current status is unroutable then we need to make sure that we don't overwrite that status with Success (ack).
         ex.on_return do |return_info, properties, content|
-          # log.debug "Got a returned message info: #{return_info}"
-          # log.debug "Got a returned message properties: #{properties}"
-          # log.debug "Got a returned message content: #{content}"
-
-          # ::Istox::BunnyBoot.find_trackers("message_id:#{properties[:message_id]}").each do |key|
-          #  log.debug("On_return, update key #{key} in redis on status and retry counter")
-          #  ::Istox::BunnyBoot.update_tracker_by_status(key, 2)
-          #  ::Istox::BunnyBoot.update_tracker_incr_retry(key)
-          # end
-
-          # publish(return_info[:exchange], return_info[:routing_key], content)
+          return_info = return_info.to_hash
+          properties = properties.to_hash
+          log.debug "Got a returned message info: #{return_info}"
+          log.debug "Got a returned message properties: #{properties}"
+          log.debug "Got a returned message content: #{content}"
+=begin
+          ::Istox::BunnyBoot.find_trackers("message_id:#{properties[:message_id]}").each do |key|
+            log.debug("On_return, update key #{key} in redis on status and retry counter")
+            ::Istox::BunnyBoot.update_tracker_by_status(key, 2)
+            ::Istox::BunnyBoot.update_tracker_incr_retry(key)
+          end
+=end
+          options = properties.clone
+          options[:routing_key] = return_info[:routing_key]
+          republish(ex, options, content)
         end
 
         exchanges[id] = ex
       end
 
-      def channel_confirm?(ch)
-        ch.using_publisher_confirmations?
-      end
-
       def channel_next_tag(ch)
         ch.next_publish_seq_no
       end
 
+      # Handle republish: check and increase retry count
+      def republish(ex, options = {}, message)
+        options[:headers] = {} if options[:headers].nil?
+
+        if options[:headers][:republish].nil?
+          options[:headers][:republish] = true
+          options[:headers][:republish_count] = 1
+        else
+          options[:headers][:republish_count] += 1
+          if options[:headers][:republish_count] > 10
+            log.info "Already retry to publish for 10 times, and give up retry"
+            log.info "Publish options: #{options.inspect}"
+            log.info "Publish to exchange: #{ex.name}"
+            log.info "Publish payload: #{message.inspect}"
+            return false
+          end
+        end
+
+        log.info "Retry to publish for <#{options[:headers][:republish_count]}> times"
+        do_publish(ex, options, message)
+      end
+
       def do_publish(ex, options = {}, message)
         eid = ::Istox::BunnyBoot.eid ex
         ch = ex.channel
         channel_id = ch.id
-        confirm = channel_confirm? ch
+        confirm =  ::Istox::BunnyBoot.channel_confirm? ch
         mode = confirm_mode eid
 
         ::Istox::BunnyBoot.publish(ex, message, options)
+=begin
         if confirm
           delivery_tag = channel_next_tag ch
           if options[:message_id].nil?
@@ -216,36 +239,45 @@ module Istox
             ::Istox::BunnyBoot.rename_tracker channel_id, options[:delivery_tag], delivery_tag
           end
         end
+=end
 
         if confirm && mode == 0
           success = ex.channel.wait_for_confirms
           if success
-            ::Istox::BunnyBoot.del_tracker_on_channel channel_id
+            log.debug("Message confirm success: remove message for #{channel_id}")
+            # ::Istox::BunnyBoot.del_tracker_on_channel channel_id
+            # republish(ex, options, message)
+            true
           else
             ex.channel.nacked_set.each do |n|
               log.debug("Publish Error: UNACK delivery tag is #{n}, republish message")
-              options = ::Istox::BunnyBoot.find_tracker_on_channel(channel_id, n, 'options')
-              options = JSON.parse(options, :symbolize_names => true)
-              options[:delivery_tag] = n
-              do_publish(ex, options, message)
+              # options = ::Istox::BunnyBoot.find_tracker_on_channel(channel_id, n, 'options')
+              # options = JSON.parse(options, :symbolize_names => true)
+              # options[:delivery_tag] = n
+              republish(ex, options, message)
             end
           end
         end
       rescue Bunny::ConnectionClosedError => e
         log.debug "Publish fails due to #{e}"
-        sleep 1
-        do_publish(ex,options,message)
+        # For network related retry, sleep 2 second before retry
+        # Because it may take some seconds for automatic recovery of network
+        sleep 2
+        republish(ex,options,message)
       rescue => e
-        log.debug "Error happens: #{e.message}"
+        log.debug "Publish error happening: #{e.message}"
 
         # If the error indicates that the channel is already closed
         # then clear hash @channel and @exchange
+        # re-create channel and re-declare exchange on that channel 
         if e.message.include? "cannot use a closed channel"
           @channel.delete Thread.current.object_id
           @exchanges.delete Thread.current.object_id
           ex = exchange(eid)
-          do_publish(ex, options, message)
         end
+
+        # Republish msg
+        republish(ex, options, message)
       end
     end
   end

data/lib/istox/version.rb

@@ -1,3 +1,3 @@
 module Istox
-  VERSION = '0.1.155.1'.freeze
+  VERSION = '0.1.156'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: istox
 version: !ruby/object:Gem::Version
-  version: 0.1.155.1
+  version: 0.1.156
 platform: ruby
 authors:
 - Siong Leng
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-06 00:00:00.000000000 Z
+date: 2020-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amazing_print
@@ -524,7 +524,7 @@ files:
 homepage: http://www.abc.com
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -539,8 +539,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: istox backend shared gem
 test_files: []