promiscuous 0.25 → 0.31.0

data/lib/promiscuous/publisher/mongoid/defer.rb

@@ -1,75 +0,0 @@
-module Promiscuous::Publisher::Mongoid::Defer
-  extend ActiveSupport::Concern
-  include Promiscuous::Publisher::Envelope
-
-  mattr_accessor :klasses
-  mattr_accessor :collections
-  self.klasses = {}
-  self.collections = {}
-
-  def publish
-    super unless should_defer?
-  end
-
-  def payload
-    super.merge(:version => instance._psv)
-  end
-
-  def should_defer?
-    if options.has_key?(:defer)
-      options[:defer]
-    else
-      operation == :update
-    end
-  end
-
-  def self.hook_mongoid
-    return if @mongoid_hooked
-    @mongoid_hooked = true
-
-    Moped::Query.class_eval do
-      alias_method :update_orig, :update
-      def update(change, flags = nil)
-        change = promiscuous_seasoning(change)
-        update_orig(change, flags)
-      end
-
-      alias_method :modify_orig, :modify
-      def modify(change, options={})
-        change = promiscuous_seasoning(change) unless options[:bypass_promiscuous]
-        modify_orig(change, options)
-      end
-
-      def promiscuous_seasoning(change)
-        if Promiscuous::Publisher::Mongoid::Defer.collections[@collection.name]
-          change = change.dup
-          change['$set'] ||= {}
-          change['$inc'] ||= {}
-          change['$set'].merge!(:_psp => true)
-          change['$inc'].merge!(:_psv => 1)
-        end
-        change
-      end
-    end
-  end
-
-  module ClassMethods
-    def setup_class_binding
-      super
-      klass.class_eval do
-        cattr_accessor :publisher_defer_hooked
-        return if self.publisher_defer_hooked
-        self.publisher_defer_hooked = true
-
-        # TODO Make sure we are not overriding a field, although VERY unlikly
-        field :_psp, :type => Boolean
-        field :_psv, :type => Integer
-        index({:_psp => 1}, :background => true, :sparse => true)
-
-        Promiscuous::Publisher::Mongoid::Defer.hook_mongoid
-        Promiscuous::Publisher::Mongoid::Defer.klasses[self.to_s] = self
-        Promiscuous::Publisher::Mongoid::Defer.collections[collection.name] = true
-      end if klass
-    end
-  end
-end

data/lib/promiscuous/publisher/mongoid/defer_embedded.rb

@@ -1,25 +0,0 @@
-module Promiscuous::Publisher::Mongoid::DeferEmbedded
-  extend ActiveSupport::Concern
-
-  def payload
-    if instance.is_a?(Array)
-      Promiscuous::Publisher::Mongoid::EmbeddedMany.new(:instance => instance).payload
-    else
-      super.merge(:id => instance.id)
-    end
-  end
-
-  included do
-    klass.class_eval do
-      callback = proc do
-        if _parent.respond_to?(:promiscuous_publish_update)
-          _parent.promiscuous_publish_update
-        end
-      end
-
-      before_create callback
-      before_update callback
-      before_destroy callback
-    end
-  end
-end

data/lib/promiscuous/publisher/worker.rb

@@ -1,101 +0,0 @@
-class Promiscuous::Publisher::Worker
-  include Promiscuous::Common::Worker
-
-  def self.poll_delay
-    # TODO Configurable globally
-    # TODO Configurable per publisher
-    1.second
-  end
-
-  def initialize(options={})
-    super
-    check_indexes
-  end
-
-  def check_indexes
-    Promiscuous::Publisher::Mongoid::Defer.klasses.values.each do |klass|
-      unless klass.collection.indexes.any? { |i| i['key'].keys.include? '_psp' }
-        raise 'Please run rake db:mongoid:create_indexes'
-      end
-    end
-  end
-
-  def resume
-    @timer ||= EM::PeriodicTimer.new(self.class.poll_delay) { self.replicate_once }
-    super
-  end
-
-  def stop
-    @timer.try(:cancel)
-    @timer = nil
-    super
-  end
-
-  def replicate_once
-    return if self.stopped?
-
-    self.unit_of_work('publisher') do
-      maybe_rescue_instance
-      replicate_all_collections
-    end
-  rescue Exception => e
-    unless e.is_a?(Promiscuous::Error::Publisher)
-      e = Promiscuous::Error::Publisher.new(e)
-    end
-
-    retry_msg = stop_for_a_while(e)
-    Promiscuous.warn "[publish] (#{retry_msg}) #{e} #{e.backtrace.join("\n")}"
-
-    if e.out_of_sync
-      Promiscuous.error "[publish] WARNING out of sync on #{e.instance.inspect}"
-      @out_of_sync_instance = e.instance
-    end
-
-    Promiscuous::Config.error_notifier.try(:call, e)
-  end
-
-  def replicate_all_collections
-    Promiscuous::Publisher::Mongoid::Defer.klasses.values.each do |klass|
-      replicate_collection(klass)
-    end
-    made_progress
-  end
-
-  def replicate_collection(klass)
-    loop do
-      break if self.stopped?
-
-      instance = klass.where(:_psp => true).
-                   find_and_modify({'$unset' => {:_psp => 1}}, :bypass_promiscuous => true)
-      break unless instance
-
-      replicate_instance(instance)
-    end
-  end
-
-  def replicate_instance(instance)
-    instance.promiscuous_sync
-    made_progress
-  rescue Exception => e
-    out_of_sync = requeue_instance(instance)
-    raise Promiscuous::Error::Publisher.new(e, :instance    => instance,
-                                               :out_of_sync => out_of_sync)
-  end
-
-  def requeue_instance(instance)
-    # The following update will set the _psp flag to true again,
-    # effectively requeuing the publish action.
-    instance.class.where(instance.atomic_selector).update({})
-    false
-  rescue Exception
-    # Swallow exception of a failed recovery.
-    # The user needs to manually resync.
-    true
-  end
-
-  def maybe_rescue_instance
-    return unless @out_of_sync_instance
-    replicate_instance(@out_of_sync_instance)
-    @out_of_sync_instance = nil
-  end
-end

data/lib/promiscuous/subscriber/mongoid/versioning.rb

@@ -1,40 +0,0 @@
-module Promiscuous::Subscriber::Mongoid::Versioning
-  extend ActiveSupport::Concern
-
-  module AtomicSelector
-    extend ActiveSupport::Concern
-
-    def atomic_selector
-      if use_atomic_promiscuous_selector
-        super.merge({ '$or' => [{'_psv' => { '$lte'    => self._psv }},
-                                {'_psv' => { '$exists' => false     }}]})
-      else
-        super
-      end
-    end
-
-    included do
-      attr_accessor :use_atomic_promiscuous_selector
-      field :_psv, :type => Integer
-    end
-  end
-
-  def save_instance
-    if version
-      instance._psv = version
-      instance.use_atomic_promiscuous_selector = true
-    end
-    super
-  ensure
-    instance.use_atomic_promiscuous_selector = false
-  end
-
-  included { use_payload_attribute :version }
-
-  module ClassMethods
-    def setup_class_binding
-      super
-      klass.__send__(:include, AtomicSelector) if klass
-    end
-  end
-end