promiscuous 0.90.0 → 0.91.0

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

@@ -4,7 +4,7 @@ raise "moped > 1.3.2 please"    unless Gem.loaded_specs['moped'].version   >= Ge
 require 'yaml'
 
 class Moped::PromiscuousCollectionWrapper < Moped::Collection
-  class PromiscuousCollectionOperation < Promiscuous::Publisher::Operation::Base
+  class PromiscuousCollectionOperation < Promiscuous::Publisher::Operation::Atomic
     def initialize(options={})
       super
       @operation = :create
@@ -21,13 +21,13 @@ class Moped::PromiscuousCollectionWrapper < Moped::Collection
     rescue NameError
     end
 
-    def serialize_document_for_create_recovery
-      # TODO the serialization/deserialization is not very nice, but we need
-      # the bson types.
-      @document.to_yaml
+    def recovery_payload
+      # We use yaml because we need the BSON types.
+      [@instance.class.promiscuous_collection_name, @instance.id, @document.to_yaml]
     end
 
-    def self.recover_operation(model, instance_id, document)
+    def self.recover_operation(collection, instance_id, document)
+      model = Promiscuous::Publisher::Model::Mongoid.collection_mapping[collection]
       document = YAML.load(document)
       instance = Mongoid::Factory.from_db(model, document)
       new(:collection => model.collection, :document => document, :instance => instance)
@@ -40,18 +40,17 @@ class Moped::PromiscuousCollectionWrapper < Moped::Collection
       end
     end
 
-    def stash_version_in_write_query
-      @document[VERSION_FIELD] = @instance_version
-    end
-
-    def execute_persistent(&db_operation)
+    def execute_instrumented(query)
       @instance = Mongoid::Factory.from_db(model, @document)
       super
     end
 
-    def execute(&db_operation)
-      return db_operation.call unless model
-      super
+    def should_instrument_query?
+      super && model
+    end
+
+    def recoverable_failure?(exception)
+      exception.is_a?(Moped::Errors::ConnectionFailure)
     end
   end
 
@@ -74,8 +73,39 @@ class Moped::PromiscuousCollectionWrapper < Moped::Collection
 end
 
 class Moped::PromiscuousQueryWrapper < Moped::Query
-  class PromiscuousQueryOperation < Promiscuous::Publisher::Operation::Base
-    attr_accessor :raw_instance, :new_raw_instance, :change
+  module PromiscuousHelpers
+    def collection_name
+      @collection_name ||= @query.collection.is_a?(String) ? @query.collection : @query.collection.name
+    end
+
+    def model
+      @model ||= Promiscuous::Publisher::Model::Mongoid.collection_mapping[collection_name]
+    end
+
+    def get_selector_instance
+      selector = @query.operation.selector["$query"] || @query.operation.selector
+
+      # TODO use the original instance for an update/delete, that would be
+      # an even better hint.
+
+      # We only support == selectors, no $in, or $gt.
+      @selector = selector.select { |k,v| k.to_s =~ /^[^$]/ && !v.is_a?(Hash) }
+
+      # @instance is not really a proper instance of a model, it's just a
+      # convenient representation of a selector as explain in base.rb,
+      # which explain why we don't want any constructor to be called.
+      # Note that this optimistic mechanism also works with writes because
+      # the instance gets reloaded once the lock is taken. If the
+      # dependencies were incorrect, the locks will be released and
+      # reacquired appropriately.
+      model.allocate.tap { |doc| doc.instance_variable_set(:@attributes, @selector) }
+    end
+  end
+
+  class PromiscuousWriteOperation < Promiscuous::Publisher::Operation::Atomic
+    include Moped::PromiscuousQueryWrapper::PromiscuousHelpers
+
+    attr_accessor :change
 
     def initialize(options={})
       super
@@ -83,87 +113,60 @@ class Moped::PromiscuousQueryWrapper < Moped::Query
       @change = options[:change]
     end
 
-    def collection_name
-      @collection_name ||= @query.collection.is_a?(String) ? @query.collection : @query.collection.name
+    def recovery_payload
+      [@instance.class.promiscuous_collection_name, @instance.id]
     end
 
-    def model
-      @model ||= Promiscuous::Publisher::Model::Mongoid.collection_mapping[collection_name]
+    def self.recover_operation(collection, instance_id)
+      # TODO We need to use the primary database. We cannot read from a secondary.
+      model = Promiscuous::Publisher::Model::Mongoid.collection_mapping[collection]
+      query = model.unscoped.where(:id => instance_id).query
+
+      # We no-op the update operation instead of making it idempotent.
+      # To do so, we do a dummy update on the document.
+      # The original caller will fail because the lock was unlocked, so we'll
+      # won't send a different message.
+      new(:query => query, :change => {}).tap { |op| op.instance_eval { reload_instance } }
     end
 
-    def self.recover_operation(model, instance_id, document)
-      # TODO We need to use the primary database. We cannot read from a
-      # secondary.
-      query = model.unscoped.where(:id => instance_id).query
-      op = new(:query => query, :change => {})
-      # TODO refactor this not so pretty instance_eval
-      op.instance_eval do
-        reload_instance
-        @instance ||= get_selector_instance
+    def recover_db_operation
+      if operation == :update
+        without_promiscuous { @query.update(@change) }
+      else
+        without_promiscuous { @query.remove }
       end
-      op
     end
 
-    def recover_db_operation
-      # We no-op the update/destroy operation instead of making it idempotent.
-      # The original caller will fail because the lock was unlocked.
-      without_promiscuous { @query.update(@change) }
-      @operation = :dummy
+    def recoverable_failure?(exception)
+      exception.is_a?(Moped::Errors::ConnectionFailure)
     end
 
     def fetch_instance
-      @raw_instance = @new_raw_instance || without_promiscuous { @query.first }
-      Mongoid::Factory.from_db(model, @raw_instance) if @raw_instance
+      raw_instance = without_promiscuous { @query.first }
+      Mongoid::Factory.from_db(model, raw_instance) if raw_instance
     end
 
     def use_id_selector(options={})
-      selector = {'_id' => @instance.id}
+      selector = {'_id' => @instance.id}.merge(@query.selector.select { |k,v| k.to_s.include?("_id") })
 
       if options[:use_atomic_version_selector]
-        version = @instance[VERSION_FIELD]
-        selector.merge!(VERSION_FIELD => version) if version
+        version = @instance[Promiscuous::Config.version_field]
+        selector.merge!(Promiscuous::Config.version_field => version)
       end
 
       @query.selector = selector
     end
 
-    def stash_version_in_write_query
+    def stash_version_in_document(version)
       @change['$set'] ||= {}
-      @change['$set'][VERSION_FIELD] = @instance_version
+      @change['$set'][Promiscuous::Config.version_field] = version
     end
 
-    def get_selector_instance
-      selector = @query.operation.selector["$query"] || @query.operation.selector
-
-      # TODO use the original instance for an update/delete, that would be
-      # an even better hint.
-
-      # We only support == selectors, no $in, or $gt.
-      @selector = selector.select { |k,v| k.to_s =~ /^[^$]/ && !v.is_a?(Hash) }
-
-      # @instance is not really a proper instance of a model, it's just a
-      # convenient representation of a selector as explain in base.rb,
-      # which explain why we don't want any constructor to be called.
-      # Note that this optimistic mechanism also works with writes because
-      # the instance gets reloaded once the lock is taken. If the
-      # dependencies were incorrect, the locks will be released and
-      # reacquired appropriately.
-      model.allocate.tap { |doc| doc.instance_variable_set(:@attributes, @selector) }
-    end
-
-    def execute_persistent(&db_operation)
+    def execute_instrumented(query)
       # We are trying to be optimistic for the locking. We are trying to figure
       # out our dependencies with the selector upfront to avoid an extra read
       # from reload_instance.
-      @instance = get_selector_instance
-      super
-    end
-
-    def execute_non_persistent(&db_operation)
-      if multi?
-        @instance = get_selector_instance
-        @selector_keys = @selector.keys
-      end
+      @instance ||= get_selector_instance
       super
     end
 
@@ -185,48 +188,55 @@ class Moped::PromiscuousQueryWrapper < Moped::Query
       # TODO maybe we should cache these things
       # TODO discover field dependencies automatically (hard)
       aliases = Hash[model.aliased_fields.map { |k,v| [v,k] }]
-      attributes = fields_in_query(@change).map { |f| (aliases[f.to_s] || f).to_sym }
+      attributes = fields_in_query(@change).map { |f| [aliases[f.to_s], f] }.flatten.compact.map(&:to_sym)
       (attributes & model.published_db_fields).present?
     end
 
-    def execute(&db_operation)
-      return db_operation.call if @query.without_promiscuous?
-      return db_operation.call unless model
-      return db_operation.call unless any_published_field_changed?
+    def should_instrument_query?
+      super && model && any_published_field_changed?
+    end
+  end
 
-      # We cannot do multi update/destroy
-      if (operation == :update || operation == :destroy) && multi?
-        raise Promiscuous::Error::Dependency.new(:operation => self)
-      end
+  class PromiscuousReadOperation < Promiscuous::Publisher::Operation::NonPersistent
+    include Moped::PromiscuousQueryWrapper::PromiscuousHelpers
+
+    def initialize(options={})
       super
+      @operation = :read
+      @query = options[:query]
+    end
+
+    def query_dependencies
+      deps = dependencies_for(get_selector_instance)
+      deps.empty? ? super : deps
     end
-  end
 
-  def promiscuous_operation(operation, options={})
-    PromiscuousQueryOperation.new(options.merge(:query => self, :operation => operation))
+    def should_instrument_query?
+      super && model
+    end
   end
 
-  def selector=(value)
-    @selector = value
-    @operation.selector = value
+  def promiscuous_read_operation(options={})
+    PromiscuousReadOperation.new(options.merge(:query => self))
   end
 
-  def without_promiscuous!
-    @without_promiscuous = true
+  def promiscuous_write_operation(operation, options={})
+    PromiscuousWriteOperation.new(options.merge(:query => self, :operation => operation))
   end
 
-  def without_promiscuous?
-    !!@without_promiscuous
+  def selector=(value)
+    @selector = value
+    @operation.selector = value
   end
 
   # Moped::Query
 
   def count(*args)
-    promiscuous_operation(:read, :multi => true, :operation_ext => :count).execute { super }.to_i
+    promiscuous_read_operation(:operation_ext => :count).execute { super }.to_i
   end
 
   def distinct(key)
-    promiscuous_operation(:read, :multi => true).execute { super }
+    promiscuous_read_operation(:operation_ext => :distinct).execute { super }
   end
 
   def each
@@ -240,68 +250,82 @@ class Moped::PromiscuousQueryWrapper < Moped::Query
   alias :cursor :each
 
   def first
-    # TODO If the the user is using something like .only(), we need to make
-    # sure that we add the id, otherwise we may not be able to perform the
-    # dependency optimization by resolving the selector to an id.
-    promiscuous_operation(:read).execute do |operation|
-      operation ? operation.raw_instance : super
+    # FIXME If the the user is using something like .only(), we need to make
+    # sure that we add the id, otherwise we are screwed.
+    op = promiscuous_read_operation
+
+    op.execute do |query|
+      query.non_instrumented { super }
+      query.instrumented do
+        super.tap do |doc|
+          op.instances = doc ? [Mongoid::Factory.from_db(op.model, doc)] : []
+        end
+      end
     end
   end
   alias :one :first
 
   def update(change, flags=nil)
-    multi = flags && flags.include?(:multi)
-    raise "No upsert support yet" if flags && flags.include?(:upsert)
+    update_op = promiscuous_write_operation(:update, :change => change)
+
+    if flags && update_op.should_instrument_query?
+      raise "You cannot do a multi update. Instead, update each document separately." if flags.include?(:multi)
+      raise "No upsert support yet" if flags.include?(:upsert)
+    end
 
-    promiscuous_operation(:update, :change => change, :multi => multi).execute do |operation|
-      if operation
-        operation.new_raw_instance = without_promiscuous { modify(change, :new => true) }
-        # FIXME raise when recovery raced
+    update_op.execute do |query|
+      query.non_instrumented { super }
+      query.instrumented do |op|
+        raw_instance = without_promiscuous { modify(change, :new => true) }
+        op.instance = Mongoid::Factory.from_db(op.model, raw_instance)
         {'updatedExisting' => true, 'n' => 1, 'err' => nil, 'ok' => 1.0}
-      else
-        super
       end
     end
   end
 
   def modify(change, options={})
-    promiscuous_operation(:update, :change => change).execute { super }
-    # FIXME raise when recovery raced
+    promiscuous_write_operation(:update, :change => change).execute do |query|
+      query.non_instrumented { super }
+      query.instrumented do |op|
+        raise "You can only use find_and_modify() with :new => true" if !options[:new]
+        super.tap { |raw_instance| op.instance = Mongoid::Factory.from_db(op.model, raw_instance) }
+      end
+    end
   end
 
   def remove
-    promiscuous_operation(:destroy).execute { super }
-    # FIXME raise when recovery raced
+    promiscuous_write_operation(:destroy).execute { super }
   end
 
   def remove_all
-    promiscuous_operation(:destroy, :multi => true).execute { super }
+    raise "Instead of doing a multi delete, delete each document separatly.\n" +
+          "Declare your has_many relationships with :dependent => :destroy instead of :delete"
   end
 end
 
 class Moped::PromiscuousCursorWrapper < Moped::Cursor
-  def promiscuous_operation(op, options={})
-    Moped::PromiscuousQueryWrapper::PromiscuousQueryOperation.new(
-      options.merge(:query => @query, :operation => op))
-  end
-
   # Moped::Cursor
-
-  def fake_single_read(operation)
-    @cursor_id = 0
-    [operation.raw_instance].compact
+  def promiscuous_read_each(&block)
+    op = Moped::PromiscuousQueryWrapper::PromiscuousReadOperation.new(
+           :query => @query, :operation_ext => :each)
+
+    op.execute do |query|
+      query.non_instrumented { block.call.to_a }
+      query.instrumented do
+        block.call.to_a.tap do |docs|
+          op.instances = docs.map { |doc| Mongoid::Factory.from_db(op.model, doc) }
+        end
+      end
+    end
   end
 
   def load_docs
-    should_fake_single_read = @limit == 1
-    promiscuous_operation(:read, :multi => !should_fake_single_read).execute do |operation|
-      operation && should_fake_single_read ? fake_single_read(operation) : super
-    end.to_a
+    promiscuous_read_each { super }
   end
 
   def get_more
     # TODO support batch_size
-    promiscuous_operation(:read, :multi => true).execute { super }
+    promiscuous_read_each { super }
   end
 
   def initialize(session, query_operation)
@@ -313,9 +337,8 @@ end
 class Moped::PromiscuousDatabase < Moped::Database
   # TODO it might be safer to use the alias attribute method because promiscuous
   # may come late in the loading.
-  def promiscuous_operation(op, options={})
-    Moped::PromiscuousQueryWrapper::PromiscuousQueryOperation.new(
-      options.merge(:operation => op))
+  def promiscuous_read_operation(options={})
+    Moped::PromiscuousQueryWrapper::PromiscuousReadOperation.new(options)
   end
 
   # Moped::Database
@@ -323,29 +346,13 @@ class Moped::PromiscuousDatabase < Moped::Database
   def command(command)
     if command[:mapreduce]
       query = Moped::Query.new(self[command[:mapreduce]], command[:query])
-      promiscuous_operation(:read, :query => query,
-                            :operation_ext => :mapreduce, :multi => true).execute { super }
+      promiscuous_read_operation(:query => query, :operation_ext => :mapreduce).execute { super }
     else
       super
     end
   end
 end
 
-class Mongoid::Contextual::Mongo
-  alias_method :each_hijacked, :each
-
-  def each(&block)
-    query.without_promiscuous! if criteria.options[:without_promiscuous]
-    each_hijacked(&block)
-  end
-end
-
-module Origin::Optional
-  def without_promiscuous
-    clone.tap { |criteria| criteria.options.store(:without_promiscuous, true) }
-  end
-end
-
 class Mongoid::Validations::UniquenessValidator
   alias_method :validate_root_without_promisucous, :validate_root
   def validate_root(*args)
@@ -354,7 +361,8 @@ class Mongoid::Validations::UniquenessValidator
 end
 
 class Moped::BSON::ObjectId
-  # No {"$oid": "123"}, it's horrible
+  # No {"$oid": "123"}, it's horrible.
+  # TODO Document this shit.
   def to_json(*args)
     "\"#{to_s}\""
   end

data/lib/promiscuous/publisher/operation/non_persistent.rb

@@ -0,0 +1,28 @@
+class Promiscuous::Publisher::Operation::NonPersistent < Promiscuous::Publisher::Operation::Base
+  # XXX As opposed to atomic operations, NonPersistent operations deals with an
+  # array of instances
+  attr_accessor :instances
+
+  def initialize(options={})
+    super
+    @instances = options[:instances].to_a
+  end
+
+  def execute_instrumented(db_operation)
+    db_operation.call_and_remember_result(:instrumented)
+
+    unless db_operation.failed?
+      current_context.read_operations << self if read?
+      trace_operation
+    end
+  end
+
+  def operation_payloads
+    return [] if self.failed?
+    @instances.map { |instance| payloads_for(instance) }
+  end
+
+  def query_dependencies
+    @instances.map { |instance| dependencies_for(instance) }
+  end
+end

data/lib/promiscuous/publisher/operation/proxy_for_query.rb

@@ -0,0 +1,42 @@
+class Promiscuous::Publisher::Operation::ProxyForQuery
+  attr_accessor :exception, :result
+
+  def initialize(operation, &block)
+    @operation = operation
+    @queries = {}
+
+    if block.arity == 1
+      block.call(self)
+    else
+      self.non_instrumented { block.call }
+      self.instrumented { block.call }
+    end
+  end
+
+  def prepare(&block)
+    @queries[:prepare] = block
+  end
+
+  def non_instrumented(&block)
+    @queries[:non_instrumented] = block
+  end
+
+  def instrumented(&block)
+    @queries[:instrumented] = block
+  end
+
+  def call_and_remember_result(which)
+    raise "Fatal: #{which} query unspecified" unless @queries[which]
+    @result = @queries[which].call(@operation)
+  rescue Exception => e
+    @exception = e
+  end
+
+  def failed?
+    !!@exception
+  end
+
+  def result
+    failed? ? (raise @exception) : @result
+  end
+end

data/lib/promiscuous/publisher/operation/transaction.rb

@@ -0,0 +1,85 @@
+class Promiscuous::Publisher::Operation::Transaction < Promiscuous::Publisher::Operation::Base
+  attr_accessor :transaction_id, :transaction_operations, :operation_payloads
+
+  def initialize(options={})
+    super
+    @operation = :commit
+    @transaction_operations = options[:transaction_operations].to_a
+    @transaction_id = options[:transaction_id]
+    @operation_payloads = options[:operation_payloads]
+  end
+
+  def dependency_for_op_lock
+    # We don't take locks on rows as the database already have the locks on them
+    # until the transaction is committed.
+    # A lock on the transaction ID is taken so we know when we conflict with
+    # the recovery mechanism.
+    Promiscuous::Dependency.new("__transactions__", self.transaction_id, :dont_hash => true)
+  end
+
+  def pending_writes
+    # TODO (performance) Return a list of writes that:
+    # - Never touch the same id (the latest write is sufficient)
+    # - create/update and then delete should be invisible
+    @transaction_operations
+  end
+
+  def query_dependencies
+    @query_dependencies ||= pending_writes.map(&:query_dependencies).flatten
+  end
+
+  def operation_payloads
+    @operation_payloads ||= pending_writes.map(&:operation_payloads).flatten
+  end
+
+  alias cache_operation_payloads operation_payloads
+
+  def should_instrument_query?
+    super && !pending_writes.empty?
+  end
+
+  def execute_instrumented(query)
+    unless self.recovering?
+      generate_read_dependencies
+      acquire_op_lock
+
+      # As opposed to atomic operations, we know the values of the instances
+      # before the database operation, and not after, so only one stage
+      # of recovery is used.
+      cache_operation_payloads
+
+      query.call_and_remember_result(:prepare)
+    end
+
+    self.increment_read_and_write_dependencies
+
+    query.call_and_remember_result(:instrumented)
+
+    # We can't do anything if the prepared commit doesn't go through.
+    # Either it's a network failure, or the database is having some real
+    # difficulties. The recovery mechanism will have to retry the transaction.
+    return if query.failed?
+
+    # We take a timestamp right after the write is performed because latency
+    # measurements are performed on the subscriber.
+    record_timestamp
+
+    ensure_op_still_locked
+
+    generate_payload
+    clear_previous_dependencies
+
+    publish_payload_in_redis
+    release_op_lock
+    publish_payload_in_rabbitmq_async
+  end
+
+  def recovery_payload
+    # TODO just save the table/ids, or publish the real payload directly.
+    [@transaction_id, @operation_payloads]
+  end
+
+  def self.recover_operation(transaction_id, operation_payloads)
+    new(:transaction_id => transaction_id, :operation_payloads => operation_payloads)
+  end
+end

data/lib/promiscuous/publisher/operation.rb

@@ -1,4 +1,4 @@
 module Promiscuous::Publisher::Operation
   extend Promiscuous::Autoload
-  autoload :Base
+  autoload :Base, :Transaction, :Atomic, :NonPersistent, :ProxyForQuery
 end

data/lib/promiscuous/publisher/worker.rb

@@ -1,11 +1,10 @@
 class Promiscuous::Publisher::Worker
   def initialize
-    @recovery_timer = Promiscuous::Timer.new
-    @timeout = Promiscuous::Config.recovery_timeout
+    @recovery_timer = Promiscuous::Timer.new("recovery", Promiscuous::Config.recovery_timeout) { try_recover }
   end
 
   def start
-    @recovery_timer.run_every(@timeout, :run_immediately => true) { try_recover }
+    @recovery_timer.start(:run_immediately => true)
   end
 
   def stop
@@ -13,10 +12,11 @@ class Promiscuous::Publisher::Worker
   end
 
   def try_recover
-    Promiscuous::Publisher::Operation::Base.recover_locks
-    Promiscuous::Publisher::Operation::Base.recover_payloads_for_rabbitmq
+    Promiscuous::Publisher::Operation::Base.run_recovery_mechanisms
   rescue Exception => e
-    Promiscuous.warn "[recovery] #{e} #{e.backtrace.join("\n")}"
-    Promiscuous::Config.error_notifier.try(:call, e)
+    Promiscuous.warn "[recovery] #{e}\n#{e.backtrace.join("\n")}"
+    Promiscuous::Config.error_notifier.call(e)
+  ensure
+    ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
   end
 end

data/lib/promiscuous/publisher.rb

@@ -1,6 +1,6 @@
 module Promiscuous::Publisher
   extend Promiscuous::Autoload
-  autoload :Model, :Operation, :MockGenerator, :Context, :Worker
+  autoload :Model, :Operation, :MockGenerator, :Context, :Worker, :Bootstrap
 
   extend ActiveSupport::Concern