multiple_man 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d859ac14aeccc95ff5ab2ec4d1b5e4cb07f18e77
-  data.tar.gz: e5723029260e45a9012c8394ca3b7c4e9fab8535
+  metadata.gz: 8dbcb9ce65f9deaea7bc949150dcad625861594e
+  data.tar.gz: f6fd179c4f92d65d0df27c23ad13bfeaf0359e37
 SHA512:
-  metadata.gz: f696e8233f25addccab4bd17b2fe2757dd798664aaf727327ce615b60b92a18e3e2da568d10af11b26e780ffd1be0ead24b922a4a30bb1fda01def94ed636167
-  data.tar.gz: 750cd59c5e45f14aa97f915bd9ddb2a371ff7f982435cb0629fb3821204de619a132950bcbde2ed1721b1ecd2c1548930caa74e27cd7d98d613b8f4bb93f9fa5
+  metadata.gz: 8e53300b5197df7628f32a22f8440a03a2d4c91977b4e3ea6a4033b3a6a02f6832862ac1f30744295f12bd2690495cf9e24046fb58947d59933c0a90e942995e
+  data.tar.gz: 9b3a72cb0e46d7560b0b2736650928587f1f2ab21f8b30ce506dbfd66fc37a4af57e2dd1663a07397a8d5025e7d71e00e3721471fc865a79281ec8de14a7e279

data/README.md

@@ -157,7 +157,7 @@ def ListenerClass
     # do something when a model is created
   end
 end
-``
+```
 
 ## Listening for subscriptions
 

data/lib/multiple_man/channel_maintenance/gc.rb

@@ -0,0 +1,101 @@
+module MultipleMan
+  module ChannelMaintenance
+    class GC
+      def self.finalizer(thread_id, channel, queue, reaper)
+        proc { queue << RemoveCommand.new(thread_id); reaper.push(channel) }
+      end
+
+      def initialize(config, reaper)
+        @reaper = reaper
+        @queue = Queue.new
+
+        @executor = Thread.new do
+          channels_by_thread = Hash.new {|h, k| h[k] = [] }
+          loop do
+            begin
+              command = queue.pop
+              command.execute(channels_by_thread)
+            rescue
+              puts "Sweeper died", $!
+            end
+          end
+        end
+
+        @sweeper_thread = Thread.new do
+          loop do
+            sleep 15
+            queue << SweepCommand.new(queue, reaper)
+          end
+        end
+      end
+
+      def push(channel)
+        thread_id = Thread.current.object_id
+
+        finalizer = self.class.finalizer(thread_id, channel, queue, reaper)
+        ObjectSpace.define_finalizer(Thread.current, finalizer)
+
+        queue << AddCommand.new(thread_id, channel)
+
+        puts "Opened channel #{channel.number}"
+        self
+      end
+
+      def stop
+        executor.kill
+        executor.join
+
+        sweeper_thread.kill
+        sweeper_thread.join
+
+        reaper.stop
+      end
+
+      private
+      attr_reader :queue, :reaper, :executor, :sweeper_thread
+
+      class AddCommand
+        attr_reader :thread_id, :channel
+
+        def initialize(thread_id, channel)
+          @thread_id = thread_id
+          @channel = channel
+        end
+
+        def execute(channels_by_thread)
+          channels_by_thread[thread_id] << channel
+        end
+      end
+
+      class RemoveCommand
+        attr_reader :thread_id
+
+        def initialize(thread_id)
+          @thread_id = thread_id
+        end
+
+        def execute(channels_by_thread)
+          channels_by_thread.delete(thread_id)
+        end
+      end
+
+      class SweepCommand
+        attr_reader :queue, :reaper
+        def initialize(queue, reaper)
+          @queue = queue
+          @reaper = reaper
+        end
+
+        def execute(channels_by_thread)
+          channels_by_thread.each do |thread_id, channels|
+            thing = ObjectSpace._id2ref(thread_id) rescue nil
+            next if thing.kind_of?(Thread) && thing.alive?
+
+            channels.each {|c| reaper.push(c)}
+            queue << RemoveCommand.new(thread_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/multiple_man/channel_maintenance/reaper.rb

@@ -0,0 +1,35 @@
+module MultipleMan
+  module ChannelMaintenance
+    class Reaper
+      def initialize(config)
+        @config = config
+        @queue = Queue.new
+
+        @worker = Thread.new do
+          loop do
+            channel = queue.pop
+            begin
+              channel.close unless closed?
+              puts "Channel #{channel.number} closed!"
+            rescue Exception
+              sleep config.connection_recovery[:time_between_retries]
+              retry
+            end
+          end
+        end
+      end
+
+      def push(channel)
+        queue << channel
+      end
+
+      def stop
+        worker.kill
+        worker.join
+      end
+
+      private
+      attr_reader :config, :queue, :worker
+    end
+  end
+end

data/lib/multiple_man/configuration.rb

@@ -5,9 +5,13 @@ module MultipleMan
       self.topic_name = "multiple_man"
       self.app_name = Rails.application.class.parent.to_s if defined?(Rails)
       self.enabled = true
-      self.channel_pool_size = 5
       self.worker_concurrency = 1
       self.reraise_errors = true
+      self.connection_recovery = {
+        time_before_reconnect: 0.2,
+        time_between_retries: 0.8,
+        max_retries: 5
+      }
     end
 
     def logger
@@ -18,8 +22,8 @@ module MultipleMan
       @error_handler = block
     end
 
-    attr_accessor :topic_name, :app_name, :connection, :enabled, :channel_pool_size, :error_handler, 
-                  :worker_concurrency, :reraise_errors
+    attr_accessor :topic_name, :app_name, :connection, :enabled, :error_handler,
+                  :worker_concurrency, :reraise_errors, :connection_recovery
     attr_writer :logger
   end
 
@@ -30,4 +34,4 @@ module MultipleMan
   def self.configure
     yield(configuration) if block_given?
   end
-end
+end

data/lib/multiple_man/connection.rb

@@ -1,22 +1,79 @@
 require 'bunny'
-require 'connection_pool'
 require 'active_support/core_ext/module'
 
 module MultipleMan
   class Connection
+    @mutex = Mutex.new
 
     def self.connect
-      connection = Bunny.new(MultipleMan.configuration.connection)
-      MultipleMan.logger.debug "Connecting to #{MultipleMan.configuration.connection}"
-      connection.start
-      channel = connection.create_channel
-      yield new(channel) if block_given?
-    ensure
-      channel.close if channel && channel.open?
-      connection.close if connection && connection.open?
+      yield new(channel)
+      Thread.current[:multiple_man_exception_retry_count] = 0
+    rescue Bunny::Exception, Timeout::Error => e
+      recovery_options = MultipleMan.configuration.connection_recovery
+      MultipleMan.logger.debug "Bunny Error: #{e.inspect}"
+
+      retry_count = Thread.current[:multiple_man_exception_retry_count] || 0
+      retry_count += 1
+
+      if retry_count < recovery_options[:max_retries]
+        Thread.current[:multiple_man_exception_retry_count] = retry_count
+        sleep recovery_options[:time_between_retries]
+        retry
+      else
+        Thread.current[:multiple_man_exception_retry_count] = 0
+        raise "MultipleMan::ConnectionError"
+      end
+    rescue Exception => e
+      Infl::Errors::Logger.log(e)
+      raise
+    end
+
+    def self.channel
+      Thread.current.thread_variable_get(:multiple_man_current_channel) || begin
+        channel = connection.create_channel
+        channel_gc.push(channel)
+        Thread.current.thread_variable_set(:multiple_man_current_channel, channel)
+
+        channel
+      end
+    end
+
+    def self.connection
+      @mutex.synchronize do
+        @connection ||= begin
+          connection = Bunny.new(
+            MultipleMan.configuration.connection,
+            heartbeat_interval: 5,
+            automatically_recover: true,
+            recover_from_connection_close: true,
+            network_recovery_interval: MultipleMan.configuration.connection_recovery[:time_before_reconnect]
+          )
+          MultipleMan.logger.debug "Connecting to #{MultipleMan.configuration.connection}"
+          connection.start
+
+          connection
+        end
+      end
+    end
+
+    def self.channel_gc
+      @channel_gc ||= ChannelMaintenance::GC.new(
+        MultipleMan.configuration,
+        ChannelMaintenance::Reaper.new(MultipleMan.configuration))
+    end
+
+    def self.reset!
+      @mutex.synchronize do
+        @connection.close if @connection
+        @connection = nil
+
+        @channel_gc.stop if @channel_gc
+        @channel_gc = nil
+      end
     end
 
     attr_reader :topic
+    delegate :queue, to: :channel
 
     def initialize(channel)
       self.channel = channel
@@ -27,8 +84,6 @@ module MultipleMan
       MultipleMan.configuration.topic_name
     end
 
-    delegate :queue, to: :channel
-
   private
 
     attr_accessor :channel
@@ -36,3 +91,19 @@ module MultipleMan
 
   end
 end
+
+__END__
+
+# Possible usage
+
+Unicorn.after_fork do
+  MultipleMan::Connection.reset!
+end
+
+Sidekiq.configure_server do |config|
+  MultipleMan::Connection.reset!
+end
+
+PhusionPassenger.on_event(:starting_worker_process) do |forked|
+  MultipleMan::Connection.reset! if forked
+end

data/lib/multiple_man/listeners/seeder_listener.rb

@@ -5,7 +5,7 @@ module MultipleMan::Listeners
     end
 
     # seeds should only ever be a create
-    def operation(delivery_info)
+    def operation(delivery_info, payload)
       "create"
     end
 

data/lib/multiple_man/mixins/listener.rb

@@ -11,19 +11,19 @@ module MultipleMan
     attr_accessor :klass
     attr_accessor :operation
 
-    def create
+    def create(payload)
       # noop
     end
 
-    def update
+    def update(payload)
       # noop
     end
 
-    def destroy
+    def destroy(payload)
       # noop
     end
 
-    def seed
+    def seed(payload)
       # noop
     end
 

data/lib/multiple_man/mixins/publisher.rb

@@ -6,7 +6,11 @@ module MultipleMan
       base.extend(ClassMethods)
       if base.respond_to?(:after_commit)
         base.after_commit(on: :create) { |r| r.multiple_man_publish(:create) }
-        base.after_commit(on: :update) { |r| r.multiple_man_publish(:update) }
+        base.after_commit(on: :update) do |r|
+          if !r.respond_to?(:previous_changes) || r.previous_changes.any?
+            r.multiple_man_publish(:update)
+          end
+        end
         base.after_commit(on: :destroy) { |r| r.multiple_man_publish(:destroy) }
       end
 
@@ -28,4 +32,4 @@ module MultipleMan
       end
     end
   end
-end
+end

data/lib/multiple_man/version.rb

@@ -1,3 +1,3 @@
 module MultipleMan
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

data/lib/multiple_man.rb

@@ -22,6 +22,9 @@ module MultipleMan
   require 'multiple_man/identity'
   require 'multiple_man/publish'
 
+  require 'multiple_man/channel_maintenance/gc'
+  require 'multiple_man/channel_maintenance/reaper'
+
   def self.logger
     configuration.logger
   end

data/spec/integration/ephermal_model_spec.rb

@@ -30,8 +30,6 @@ describe "Publishing of ephermal models" do
       data: { foo: 'foo', bar: 'bar', baz: 'baz'}
     }.to_json
 
-    #MultipleMan::Connection.unstub!(:connection)
-
     expect_any_instance_of(Bunny::Exchange).to receive(:publish)
                                            .with(payload, routing_key: 'multiple_man.Ephermal.create')
 

data/spec/publisher_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MultipleMan::Publisher do 
+describe MultipleMan::Publisher do
   class MockClass
     class << self
       attr_accessor :subscriber
@@ -32,6 +32,6 @@ describe MultipleMan::Publisher do
       mock_publisher = double(MultipleMan::ModelPublisher)
       MultipleMan::ModelPublisher.any_instance.should_receive(:publish).with(my_mock, :create)
       my_mock.save
-    end 
+    end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multiple_man
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Ryan Brunner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-14 00:00:00.000000000 Z
+date: 2015-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -166,6 +166,8 @@ files:
 - Rakefile
 - lib/multiple_man.rb
 - lib/multiple_man/attribute_extractor.rb
+- lib/multiple_man/channel_maintenance/gc.rb
+- lib/multiple_man/channel_maintenance/reaper.rb
 - lib/multiple_man/configuration.rb
 - lib/multiple_man/connection.rb
 - lib/multiple_man/identity.rb
@@ -223,7 +225,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: MultipleMan syncs changes to ActiveRecord models via AMQP