promiscuous 0.31.1 → 0.32.0

data/lib/promiscuous.rb

@@ -25,5 +25,14 @@ module Promiscuous
       desc.reject! { |klass| klass.name =~ /^Promiscuous::/ }
       desc.each { |klass| klass.setup_class_binding }
     end
+
+    def healthy?
+      AMQP.ensure_connected
+      Redis.ensure_connected
+    rescue
+      false
+    else
+      true
+    end
   end
 end

data/lib/promiscuous/amqp.rb

@@ -11,6 +11,19 @@ module Promiscuous::AMQP
       @backend = "Promiscuous::AMQP::#{value.to_s.camelize.gsub(/amqp/, 'AMQP')}".constantize unless value.nil?
     end
 
-    delegate :connect, :disconnect, :connected?, :publish, :open_queue, :to => :backend
+    def lost_connection_exception
+      Promiscuous::Error::Connection.new(:service => :amqp)
+    end
+
+    def ensure_connected
+      raise lost_connection_exception unless connected?
+    end
+
+    def publish(options={})
+      ensure_connected
+      backend.publish(options)
+    end
+
+    delegate :connect, :disconnect, :connected?, :open_queue, :to => :backend
   end
 end

data/lib/promiscuous/amqp/ruby_amqp.rb

@@ -24,24 +24,30 @@ module Promiscuous::AMQP::RubyAMQP
 
     connection.on_tcp_connection_loss do |conn|
       unless conn.reconnecting?
-        Promiscuous.warn "[connection] Lost connection. Reconnecting..."
-        conn.periodically_reconnect(2)
+        e = Promiscuous::AMQP.lost_connection_exception
+        Promiscuous.warn "[amqp] #{e}. Reconnecting..."
+        Promiscuous::Config.error_notifier.try(:call, e)
 
-        exception = Promiscuous::Error::Connection.new(:amqp, 'Lost connection')
-        Promiscuous::Worker.stop # TODO XXX This doesn't belong here. hooks ?
-        Promiscuous::Config.error_notifier.try(:call, exception)
+        worker = Promiscuous::Worker.workers.first
+        worker.message_synchronizer.disconnect if worker
+
+        conn.periodically_reconnect(2.seconds)
       end
     end
 
     connection.on_recovery do |conn|
-      Promiscuous.warn "[connection] Reconnected"
-      Promiscuous::Worker.resume # TODO XXX This doesn't belong here. hooks ?
+      Promiscuous.warn "[amqp] Reconnected"
+
+      worker = Promiscuous::Worker.workers.first
+      worker.message_synchronizer.reconnect if worker
+
+      Promiscuous::AMQP::RubyAMQP.channel.recover
     end
 
     connection.on_error do |conn, conn_close|
       # No need to handle CONNECTION_FORCED since on_tcp_connection_loss takes
       # care of it.
-      Promiscuous.warn "[connection] #{conn_close.reply_text}"
+      Promiscuous.warn "[amqp] #{conn_close.reply_text}"
     end
   end
 
@@ -74,11 +80,6 @@ module Promiscuous::AMQP::RubyAMQP
 
   def self.publish(options={})
     info_msg = "(#{options[:exchange_name]}) #{options[:key]} -> #{options[:payload]}"
-
-    unless channel.connection.connected?
-      raise Promiscuous::Error::Connection.new(:amqp, 'Not connected')
-    end
-
     Promiscuous.debug "[publish] #{info_msg}"
 
     EM.next_tick do

data/lib/promiscuous/error/connection.rb

@@ -1,8 +1,17 @@
 class Promiscuous::Error::Connection < RuntimeError
-  attr_accessor :which
+  attr_accessor :service, :url
 
-  def initialize(which, msg)
-    self.which = which
-    super(msg)
+  def initialize(options={})
+    super(nil)
+    self.service = options[:service]
+    self.url = Promiscuous::Config.__send__("#{service}_url")
+  end
+
+  def message
+    "Lost connection with #{url}"
+  end
+
+  def to_s
+    message
   end
 end

data/lib/promiscuous/publisher/model.rb

@@ -22,20 +22,16 @@ module Promiscuous::Publisher::Model
     end
   end
 
-  def version
-    {:global => @global_version}
-  end
-
   def payload
-    if @dummy_commit
-      {:version => version, :operation => :dummy}
-    else
-      super.merge(:id => instance.id, :operation => operation, :version => version)
-    end
+    super.merge(:id => instance.id, :operation => operation, :version => version)
   end
 
   def include_attributes?
-    operation != :destroy
+    !operation.in? [:destroy, :dummy]
+  end
+
+  def instance
+    @new_instance || super
   end
 
   def with_lock(&block)
@@ -43,28 +39,32 @@ module Promiscuous::Publisher::Model
     return yield if operation == :create
 
     key = Promiscuous::Redis.pub_key(instance.id)
-    ::RedisLock.new(Promiscuous::Redis, key).retry(50.times).every(0.2).lock_for_update(&block)
+    # We'll block for 60 seconds before raising an exception
+    ::RedisLock.new(Promiscuous::Redis, key).retry(300).every(0.2).lock_for_update(&block)
   end
 
-  def instance
-    @new_instance || super
+  def version
+    {:global => @global_version}
+  end
+
+  def update_dependencies
+    @global_version = Promiscuous::Redis.incr(Promiscuous::Redis.pub_key('global'))
   end
 
   def commit
     ret = nil
     exception = nil
 
-    unless Promiscuous::AMQP.connected?
-      raise Promiscuous::Error::Connection.new(:amqp, 'Not connected')
-    end
+    Promiscuous::AMQP.ensure_connected
 
     with_lock do
-      @global_version = Promiscuous::Redis.incr(Promiscuous::Redis.pub_key('global'))
+      update_dependencies
       begin
         ret = yield
       rescue Exception => e
-        # save it for later
-        @dummy_commit = true
+        # we must publish something so the subscriber can sync
+        # with the updated dependencies
+        options[:operation] = :dummy
         exception = e
       end
 
@@ -75,7 +75,6 @@ module Promiscuous::Publisher::Model
       end
     end
 
-    # We always need to publish so that the subscriber can keep up
     publish
 
     raise exception if exception

data/lib/promiscuous/redis.rb

@@ -10,7 +10,10 @@ module Promiscuous::Redis
   def self.new_connection
     return Null.new if Promiscuous::Config.backend == :null
 
-    ::Redis.new(:url => Promiscuous::Config.redis_url).tap { |r| r.client.connect }
+    redis = ::Redis.new(:url => Promiscuous::Config.redis_url,
+                        :tcp_keepalive => 60)
+    redis.client.connect
+    redis
   end
 
   def self.new_celluloid_connection
@@ -32,6 +35,16 @@ module Promiscuous::Redis
     end
   end
 
+  def self.lost_connection_exception
+    Promiscuous::Error::Connection.new(:service => :redis)
+  end
+
+  def self.ensure_connected
+    Promiscuous::Redis.master.ping
+  rescue
+    raise lost_connection_exception
+  end
+
   def self.method_missing(name, *args, &block)
     self.master.__send__(name, *args, &block)
   end

data/lib/promiscuous/subscriber/model.rb

@@ -1,3 +1,5 @@
+require 'crowdtap_redis_lock'
+
 module Promiscuous::Subscriber::Model
   extend ActiveSupport::Concern
   include Promiscuous::Subscriber::Envelope
@@ -31,28 +33,68 @@ module Promiscuous::Subscriber::Model
     when :create  then fetch_new
     when :update  then fetch_existing
     when :destroy then fetch_existing
+    when :dummy   then fetch_new
     end
   end
 
   def process_attributes?
-    operation != :destroy
+    !operation.in? [:destroy, :dummy]
   end
 
-  def process
-    super
-    case operation
-    when :create  then save_instance
-    when :update  then save_instance
-    when :destroy then destroy_instance
+  def message
+    options[:message]
+  end
+
+  def with_lock(&block)
+    return yield if Promiscuous::Config.backend == :null
+
+    key = Promiscuous::Redis.sub_key(instance.id)
+    # We'll block for 60 seconds before raising an exception
+    ::RedisLock.new(Promiscuous::Redis, key).retry(300).every(0.2).lock_for_update(&block)
+  end
+
+  def verify_dependencies
+    @global_key = Promiscuous::Redis.sub_key('global')
+    Promiscuous::Redis.get(@global_key).to_i + 1 == message.global_version
+  end
+
+  def update_dependencies
+    Promiscuous::Redis.set(@global_key, message.global_version)
+    @changed_global_key = true
+  end
+
+  def publish_dependencies
+    Promiscuous::Redis.publish(@global_key, message.global_version) if @changed_global_key
+  end
+
+  def with_dependencies
+    return yield unless message && message.has_dependencies?
+
+    with_lock do
+      if verify_dependencies
+        yield
+        update_dependencies
+      else
+        Promiscuous.info "[receive] (skipped, already processed) #{message.payload}"
+      end
     end
+
+    publish_dependencies
   end
 
-  def save_instance
-    instance.save!
+  def process
+    super
+    commit
   end
 
-  def destroy_instance
-    instance.destroy
+  def commit
+    with_dependencies do
+      case operation
+      when :create  then instance.save!
+      when :update  then instance.save!
+      when :destroy then instance.destroy
+      end
+    end
   end
 
   included do

data/lib/promiscuous/subscriber/observer.rb

@@ -4,19 +4,16 @@ class Promiscuous::Subscriber::Observer < Promiscuous::Subscriber::Base
   include Promiscuous::Subscriber::Polymorphic
   include Promiscuous::Subscriber::AMQP
   include Promiscuous::Subscriber::Envelope
+  include Promiscuous::Subscriber::Model
 
   def fetch
     klass.new.tap { |o| o.id = id if o.respond_to?(:id=) }
   end
 
-  def process
-    super
-    instance.run_callbacks operation
-  end
-
-  # XXX destroy callbacks will not set attributes (they are not sent)
-  def process_attributes?
-    operation != :destroy
+  def commit
+    with_dependencies do
+      instance.run_callbacks operation unless operation == :dummy
+    end
   end
 
   def self.subscribe(options)

data/lib/promiscuous/subscriber/worker.rb

@@ -17,13 +17,13 @@ class Promiscuous::Subscriber::Worker
     self.pump = Pump.new(self)
   end
 
-  def resume
+  def start
     return unless self.stopped
     self.stopped = false
     self.runners = Runner.pool
     self.message_synchronizer = MessageSynchronizer.new(self)
-    self.message_synchronizer.resume
-    self.pump.resume
+    self.message_synchronizer.start
+    self.pump.start
   end
 
   def stop
@@ -34,6 +34,7 @@ class Promiscuous::Subscriber::Worker
     self.runners.terminate
     self.runners = nil
     self.stopped = true
+    # TODO wait for the runners to finish
   end
 
   def unit_of_work(type, &block)

data/lib/promiscuous/subscriber/worker/message.rb

@@ -15,29 +15,37 @@ class Promiscuous::Subscriber::Worker::Message
     parsed_payload['__amqp__']
   end
 
-  def has_version?
-    !!version
-  end
-
   def version
     @version ||= parsed_payload['version'].try(:symbolize_keys)
   end
 
-  def update_dependencies
-    global_key = Promiscuous::Redis.sub_key('global')
-    global_version = Promiscuous::Redis.incr global_key
-    Promiscuous::Redis.publish(global_key, global_version)
+  def global_version
+    version.try(:[], :global)
+  end
+
+  def has_dependencies?
+    !!global_version
+  end
+
+  def ack
+    EM.next_tick do
+      begin
+        metadata.ack
+      rescue
+        # We don't care if we fail, the message will be redelivered at some point
+      end
+    end
   end
 
   def process
     return if worker.stopped?
 
     Promiscuous.debug "[receive] #{payload}"
+    worker.unit_of_work(queue_name) do
+      Promiscuous::Subscriber.process(parsed_payload, :message => self)
+    end
 
-    worker.unit_of_work(queue_name) { Promiscuous::Subscriber.process(parsed_payload) }
-
-    update_dependencies
-    metadata.ack
+    ack
   rescue Exception => e
     e = Promiscuous::Error::Subscriber.new(e, :payload => payload)
     Promiscuous.warn "[receive] #{e} #{e.backtrace.join("\n")}"

data/lib/promiscuous/subscriber/worker/message_synchronizer.rb

@@ -5,11 +5,10 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
 
   def initialize(worker)
     self.worker = worker
-    @subscriptions = {}
   end
 
-  def resume
-    self.redis = Promiscuous::Redis.new_celluloid_connection
+  def start
+    connect
     main_loop!
   end
 
@@ -18,13 +17,59 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
   end
 
   def finalize
-    self.redis.client.connection.disconnect if self.redis
+    disconnect
+  end
+
+  def connect
+    @subscriptions = {}
+    self.redis = Promiscuous::Redis.new_celluloid_connection
+  end
+
+  def connected?
+    !!self.redis
+  end
+
+  def rescue_connection
+    disconnect
+    e = Promiscuous::Redis.lost_connection_exception
+
+    Promiscuous.warn "[redis] #{e}. Reconnecting..."
+    Promiscuous::Config.error_notifier.try(:call, e)
+
+    EM.next_tick { worker.pump.stop }
+    reconnect_later
+  end
+
+  def disconnect
+    self.redis.client.connection.disconnect if connected?
+  rescue
+  ensure
+    self.redis = nil
+  end
+
+  def reconnect
+    @reconnect_timer.try(:reset)
+    @reconnect_timer = nil
+
+    unless connected?
+      self.connect
+      main_loop!
+
+      Promiscuous.warn "[redis] Reconnected"
+      EM.next_tick { worker.pump.start }
+    end
   rescue
+    reconnect_later
+  end
+
+  def reconnect_later
+    @reconnect_timer ||= after(2.seconds) { reconnect }
   end
 
   def main_loop
+    redis_client = self.redis.client
     loop do
-      reply = redis.client.read
+      reply = redis_client.read
       raise reply if reply.is_a?(Redis::CommandError)
       type, subscription, arg = reply
 
@@ -36,11 +81,19 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
         find_subscription(subscription).maybe_perform_callbacks(arg)
       end
     end
+  rescue EOFError
+    # Unwanted disconnection
+    rescue_connection
+  rescue IOError => e
+    unless redis_client == self.redis.client
+      # We were told to disconnect
+    else
+      raise e
+    end
   rescue Celluloid::Task::TerminatedError
   rescue Exception => e
     Promiscuous.warn "[redis] #{e} #{e.backtrace.join("\n")}"
 
-    e = Promiscuous::Error::Connection.new(:redis, 'Lost connection')
     Promiscuous::Worker.stop
     Promiscuous::Config.error_notifier.try(:call, e)
   end
@@ -53,9 +106,15 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
   # extra care needs to be taken to avoid processing the message twice (see
   # perform()).
   def process_when_ready(msg)
-    return worker.runners.process!(msg) unless msg.has_version?
+    # Dropped messages will be redelivered as we reconnect
+    # when calling worker.pump.start
+    return unless self.redis
+
+    return worker.runners.process!(msg) unless msg.has_dependencies?
 
-    on_version Promiscuous::Redis.sub_key('global'), msg.version[:global] do
+    # The message synchronizer only takes care of happens before (>=) dependencies.
+    # The message will handle the skip logic in case of duplicates.
+    on_version Promiscuous::Redis.sub_key('global'), msg.global_version do
       worker.runners.process!(msg)
     end
   end
@@ -64,16 +123,14 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
     return unless @subscriptions
     cb = Subscription::Callback.new(version, callback)
     get_subscription(key).subscribe.add_callback(version, cb)
-    cb.maybe_perform(Promiscuous::Redis.get(key))
+    cb.current_version = Promiscuous::Redis.get(key)
   end
 
-  # state_lock must be taken before calling find_subscription()
   def find_subscription(key)
     raise "Fatal error (redis sub)" unless @subscriptions[key]
     @subscriptions[key]
   end
 
-  # state_lock must be taken before calling find_subscription()
   def get_subscription(key)
     @subscriptions[key] ||= Subscription.new(self, key)
   end
@@ -90,7 +147,6 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
       @callbacks = {}
     end
 
-    # subscribe() is called with the state_lock of the parent held
     def subscribe
       request_subscription
 
@@ -102,8 +158,6 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
     end
 
     def request_subscription
-      # We will not send two subscription requests, since we are holding
-      # the state_lock of the parent.
       return if @subscription_requested
       parent.redis.client.process([[:subscribe, key]])
       @subscription_requested = true
@@ -130,7 +184,7 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
 
     def maybe_perform_callbacks(current_version)
       @callbacks.values.each do |cb|
-        cb.maybe_perform(current_version)
+        cb.current_version = current_version
       end
     end
 
@@ -145,13 +199,22 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
       attr_accessor :subscription, :version, :callback, :token
 
       def initialize(version, callback)
+        @current_version = 0
         self.version = version
         self.callback = callback
         @token = self.class.get_next_token
       end
 
-      def can_perform?(current_version)
-        current_version.to_i + 1 >= self.version
+      def current_version=(value)
+        @current_version = value.to_i
+        maybe_perform
+        value
+      end
+
+      private
+
+      def can_perform?
+        @current_version + 1 >= self.version
       end
 
       def perform
@@ -160,8 +223,8 @@ class Promiscuous::Subscriber::Worker::MessageSynchronizer
         callback.call if subscription.remove_callback(@token)
       end
 
-      def maybe_perform(current_version)
-        perform if can_perform?(current_version)
+      def maybe_perform
+        perform if can_perform?
       end
     end
   end

data/lib/promiscuous/subscriber/worker/pump.rb

@@ -1,33 +1,29 @@
 class Promiscuous::Subscriber::Worker::Pump
+  # TODO Make this celluloid happy
   attr_accessor :worker
 
   def initialize(worker)
     self.worker = worker
   end
 
-  def resume
-    if @queue
-      # XXX TODO we should not access to the channel like this.
-      # The abstraction is leaking.
-      # Actually, we actually want one channel per worker.
-
-      # The following tells rabbitmq to resend the unacked messages
-      Promiscuous::AMQP::RubyAMQP.channel.recover
-    else
-      Promiscuous::AMQP.open_queue(queue_bindings) do |queue|
-        @queue = queue
-        @queue.subscribe({:ack => true}, &method(:process_payload))
+  def start
+    return if @queue
+    Promiscuous::AMQP.open_queue(queue_bindings) do |queue|
+      @queue = queue
+      @queue.subscribe :ack => true do |metadata, payload|
+        # we drop the payload if we switched to another queue,
+        # duplicate messages could hurt us.
+        process_payload(metadata, payload) if queue == @queue
       end
     end
   end
 
   def stop
-    # we should tell amqp that we want to stop using the queue
+    queue, @queue = @queue, nil
+    queue.unsubscribe if queue rescue nil
   end
 
   def process_payload(metadata, payload)
-    return if worker.stopped?
-
     msg = Promiscuous::Subscriber::Worker::Message.new(worker, metadata, payload)
     worker.message_synchronizer.process_when_ready(msg)
   end

data/lib/promiscuous/version.rb

@@ -1,3 +1,3 @@
 module Promiscuous
-  VERSION = '0.31.1'
+  VERSION = '0.32.0'
 end

data/lib/promiscuous/worker.rb

@@ -3,7 +3,7 @@ module Promiscuous::Worker
   self.workers = []
 
   def self.replicate(options={})
-    self.workers << Promiscuous::Subscriber::Worker.new(options).tap { |w| w.resume }
+    self.workers << Promiscuous::Subscriber::Worker.new(options).tap { |w| w.start }
   end
 
   def self.kill
@@ -16,7 +16,7 @@ module Promiscuous::Worker
     workers.each(&:stop)
   end
 
-  def self.resume
-    workers.each(&:resume)
+  def self.start
+    workers.each(&:start)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: promiscuous
 version: !ruby/object:Gem::Version
-  version: 0.31.1
+  version: 0.32.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-02 00:00:00.000000000 Z
+date: 2013-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -19,7 +19,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,7 +27,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
@@ -35,7 +35,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,71 +43,71 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: bunny
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: amqp
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.8
 - !ruby/object:Gem::Dependency
   name: em-synchrony
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.3
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.2
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -129,49 +129,49 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: celluloid
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.4
 - !ruby/object:Gem::Dependency
   name: celluloid-io
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.1
 description: Replicate your Mongoid/ActiveRecord models across your applications
 email:
 - nicolas@viennot.biz
@@ -181,9 +181,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/promiscuous/amqp/null.rb
 - lib/promiscuous/amqp/bunny.rb
 - lib/promiscuous/amqp/ruby_amqp.rb
-- lib/promiscuous/amqp/null.rb
 - lib/promiscuous/common/lint/base.rb
 - lib/promiscuous/common/class_helpers.rb
 - lib/promiscuous/common/options.rb
@@ -207,8 +207,8 @@ files:
 - lib/promiscuous/publisher/base.rb
 - lib/promiscuous/publisher/lint.rb
 - lib/promiscuous/publisher/mongoid.rb
-- lib/promiscuous/publisher/model.rb
 - lib/promiscuous/publisher/amqp.rb
+- lib/promiscuous/publisher/model.rb
 - lib/promiscuous/subscriber/lint/amqp.rb
 - lib/promiscuous/subscriber/lint/base.rb
 - lib/promiscuous/subscriber/lint/class.rb
@@ -216,26 +216,26 @@ files:
 - lib/promiscuous/subscriber/lint/attributes.rb
 - lib/promiscuous/subscriber/mongoid/embedded_many.rb
 - lib/promiscuous/subscriber/mongoid/embedded.rb
-- lib/promiscuous/subscriber/worker/message.rb
-- lib/promiscuous/subscriber/worker/runner.rb
 - lib/promiscuous/subscriber/worker/pump.rb
+- lib/promiscuous/subscriber/worker/runner.rb
 - lib/promiscuous/subscriber/worker/message_synchronizer.rb
+- lib/promiscuous/subscriber/worker/message.rb
 - lib/promiscuous/subscriber/active_record.rb
 - lib/promiscuous/subscriber/envelope.rb
 - lib/promiscuous/subscriber/upsert.rb
-- lib/promiscuous/subscriber/observer.rb
 - lib/promiscuous/subscriber/polymorphic.rb
 - lib/promiscuous/subscriber/amqp.rb
 - lib/promiscuous/subscriber/attributes.rb
-- lib/promiscuous/subscriber/model.rb
 - lib/promiscuous/subscriber/base.rb
 - lib/promiscuous/subscriber/class.rb
 - lib/promiscuous/subscriber/lint.rb
 - lib/promiscuous/subscriber/mongoid.rb
+- lib/promiscuous/subscriber/observer.rb
 - lib/promiscuous/subscriber/worker.rb
+- lib/promiscuous/subscriber/model.rb
 - lib/promiscuous/error/subscriber.rb
-- lib/promiscuous/error/connection.rb
 - lib/promiscuous/error/publisher.rb
+- lib/promiscuous/error/connection.rb
 - lib/promiscuous/observer.rb
 - lib/promiscuous/ephemeral.rb
 - lib/promiscuous/autoload.rb
@@ -243,13 +243,13 @@ files:
 - lib/promiscuous/error.rb
 - lib/promiscuous/loader.rb
 - lib/promiscuous/railtie.rb
-- lib/promiscuous/cli.rb
 - lib/promiscuous/common.rb
 - lib/promiscuous/publisher.rb
 - lib/promiscuous/worker.rb
-- lib/promiscuous/amqp.rb
 - lib/promiscuous/config.rb
+- lib/promiscuous/amqp.rb
 - lib/promiscuous/redis.rb
+- lib/promiscuous/cli.rb
 - lib/promiscuous/version.rb
 - lib/promiscuous.rb
 - bin/promiscuous