acts_as_replaceable 1.1.1 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0abcc21c226084d644f147bee703c5ee0f20cc34
+  data.tar.gz: ed37e53487557256201403234bb70c6f88750453
+SHA512:
+  metadata.gz: 01782def5552b482d0fdbc2d60a3110dfa207969dbe981459e3392b7d88fe6604858826b3a1a24e76c2635645f7283c239b922974284ba06f32cad8ff742dc27
+  data.tar.gz: 59758d67d4d29d6ec6ee76ebeb54436ebc395c51a0439c750ec9716d88d855d924392ea42b4eca42051f12353f789042fd5c12770fc00eb19db59741f114cb87

data/lib/acts_as_replaceable/acts_as_replaceable.rb

@@ -1,7 +1,7 @@
-module ActsAsReplaceable
-  class RecordNotUnique < Exception
-  end
+require 'digest'
+require 'timeout'
 
+module ActsAsReplaceable
   module ActMethod
     # If any before_save methods change the attributes,
     # acts_as_replaceable will not function correctly.
@@ -11,107 +11,176 @@ module ActsAsReplaceable
     # :insensitive_match => what fields to do case insensitive matching on.
     # :inherit => what attributes of the existing record overwrite our own attributes
     def acts_as_replaceable(options = {})
+      extend ActsAsReplaceable::ClassMethods
       include ActsAsReplaceable::InstanceMethods
 
-      options.symbolize_keys!
+      attr_reader :has_been_replaced
       cattr_accessor :acts_as_replaceable_options
+
+      options.symbolize_keys!
       self.acts_as_replaceable_options = {}
       self.acts_as_replaceable_options[:match] = ActsAsReplaceable::HelperMethods.sanitize_attribute_names(self, options[:match])
       self.acts_as_replaceable_options[:insensitive_match] = ActsAsReplaceable::HelperMethods.sanitize_attribute_names(self, options[:insensitive_match])
       self.acts_as_replaceable_options[:inherit] = ActsAsReplaceable::HelperMethods.sanitize_attribute_names(self, options[:inherit], options[:insensitive_match], :id, :created_at, :updated_at)
+
+      if ActsAsReplaceable.concurrency && !Rails.cache.respond_to?(:increment)
+        raise LockingUnavailable, "To run ActsAsReplaceable in concurrency mode, the Rails cache must provide an :increment method that performs an atomic addition to the given key, e.g. Memcached"
+      end
     end
   end
 
+  # If using parallel processes to save replaceable records, set this to true to prevent race conditions
+  def self.concurrency=(value)
+    @concurrency = value
+  end
+
+  def self.concurrency
+    !!@concurrency
+  end
+
   module HelperMethods
     def self.sanitize_attribute_names(klass, *args)
       # Intersect the proposed attributes with the column names so we don't start assigning attributes that don't exist. e.g. if the model doesn't have timestamps
       klass.column_names & args.flatten.compact.collect(&:to_s)
     end
-  end
 
-  module InstanceMethods
-    # Override the create or update method so we can run callbacks, but opt not to save if we don't need to
-    def create_record(*args)
-      find_and_replace
-      if @has_not_changed
-        logger.info "(acts_as_replaceable) Found unchanged #{self.class.to_s} ##{id} #{"- Name: #{name}" if respond_to?('name')}"
-      elsif @has_been_replaced
-        update_record(*args)
-        logger.info "(acts_as_replaceable) Updated existing #{self.class.to_s} ##{id} #{"- Name: #{name}" if respond_to?('name')}"
-      else
-        super
-        logger.info "(acts_as_replaceable) Created #{self.class.to_s} ##{id} #{"- Name: #{name}" if respond_to?('name')}"
+    # Search the incoming attributes for attributes that are in the replaceable conditions and use those to form an Find conditions
+    def self.match_conditions(record)
+      output = {}
+      record.acts_as_replaceable_options[:match].each do |attribute_name|
+        output[attribute_name] = record[attribute_name]
       end
-
-      return true
+      return output
     end
 
-    def find_and_replace
-      replace(find_duplicate)
+    def self.insensitive_match_conditions(record)
+      sql = []
+      binds = []
+      record.acts_as_replaceable_options[:insensitive_match].each do |attribute_name|
+        if value = record[attribute_name]
+          sql << "LOWER(#{attribute_name}) = ?"
+          binds << record[attribute_name].downcase
+        else
+          sql << "#{attribute_name} IS NULL"
+        end
+      end
+      return [sql.join(' AND ')] + binds
     end
 
-    private
+    # Copy attributes to existing and see how it would change if we updated it
+    # Mark all record's attributes that have changed, so even if they are
+    # still default values, they will be saved to the database
+    def self.mark_changes(record, existing)
+      copy_attributes(record.attribute_names, record, existing)
 
-    def find_duplicate
-      records = self.class.where(match_conditions).where(insensitive_match_conditions)
-      if records.length > 1
-        raise RecordNotUnique, "#{records.length} duplicate #{self.class.model_name.human.pluralize} present in database"
-      end
+      existing.changed.each {|attribute| record.send("#{attribute}_will_change!") }
 
-      return records.first
+      return existing.changed?
     end
 
-    def replace(other)
-      return unless other
-      inherit_attributes(other)
-      @new_record = false
-      @has_been_replaced = true
-      @has_not_changed = !mark_changes(other)
+    def self.copy_attributes(attributes, source, target)
+      attributes.each do |attribute|
+        target[attribute] = source[attribute]
+      end
     end
 
-    # Inherit other's attributes for those in acts_as_replaceable_options[:inherit]
-    def inherit_attributes(other)
-      acts_as_replaceable_options[:inherit].each do |attrib|
-        self[attrib] = other[attrib]
-      end
+    # Searches the database for an existing copies of record
+    def self.find_existing(record)
+      existing = record.class
+      existing = existing.where match_conditions(record)
+      existing = existing.where insensitive_match_conditions(record)
     end
 
-    def mark_changes(other)
-      attribs = self.attributes
+    # Conditionally lock (lets us enable or disable locking)
+    def self.lock_if(condition, *lock_args, &block)
+      if condition
+        lock(*lock_args, &block)
+      else
+        yield
+      end
+    end
 
-      # Copy attributes to other and see how it would change if we updated it
-      # Mark all self's attributes that have changed, so even if they are
-      # still default values, they will be saved to the database
-      attribs.each do |key, value|
-        other[key] = value
+    # A lock is used to prevent multiple threads from executing the same query simultaneously
+    # eg. In a multi-threaded environment, 'find_or_create' is prone to failure due to the possibility
+    # that the process is preempted between the 'find' and 'create' logic
+    def self.lock(record, timeout = 20)
+      lock_id  = "ActsAsReplaceable/#{Digest::MD5.digest([match_conditions(record), insensitive_match_conditions(record)].inspect)}"
+      acquired = false
+
+      # Acquire the lock by atomically incrementing and returning the value to see if we're first
+      while !acquired do
+        unless acquired = Rails.cache.increment(lock_id) == 1
+          puts "lock was in use #{lock_id}"
+          sleep(0.250)
+        end
       end
 
-      other.changed.each {|attribute| send("#{attribute}_will_change!") }
+      # Reserve the lock for only 10 seconds more than the timeout to ensure a lock is always eventually released
+      Rails.cache.write(lock_id, "1", :raw => true, :expires_in => timeout + 10)
+      Timeout::timeout(timeout) do
+        yield
+      end
 
-      return other.changed?
+    ensure # Give up the lock
+      Rails.cache.write(lock_id, "0", :raw => true) if acquired
     end
+  end
 
-    # Search the incoming attributes for attributes that are in the replaceable conditions and use those to form an Find conditions
-    def match_conditions
-      output = {}
-      acts_as_replaceable_options[:match].each do |attribute_name|
-        output[attribute_name] = self[attribute_name]
-      end
-      return output
+  module ClassMethods
+    def duplicates
+      columns = acts_as_replaceable_options[:match] + acts_as_replaceable_options[:insensitive_match]
+
+      dup_data = self.select(columns.join(', '))
+      dup_data.group! acts_as_replaceable_options[:match].join(', ')
+      dup_data.group! acts_as_replaceable_options[:insensitive_match].collect{|m| "LOWER(#{m}) AS #{m}"}.join(', ')
+      dup_data.having! "count (*) > 1"
+
+      join_condition = columns.collect{|c| "#{table_name}.#{c} = dup_data.#{c}"}.join(' AND ')
+
+      return self.joins("JOIN (#{dup_data.to_sql}) AS dup_data ON #{join_condition}")
     end
+  end
 
-    def insensitive_match_conditions
-      sql = []
-      binds = []
-      acts_as_replaceable_options[:insensitive_match].each do |attribute_name|
-        if value = self[attribute_name]
-          sql << "LOWER(#{attribute_name}) = ?"
-          binds << self[attribute_name].downcase
+  module InstanceMethods
+    # Override the create or update method so we can run callbacks, but opt not to save if we don't need to
+    def create_record(*args)
+      ActsAsReplaceable::HelperMethods.lock_if(ActsAsReplaceable.concurrency, self) do
+        find_and_replace
+        if @has_not_changed
+          logger.info "(acts_as_replaceable) Found unchanged #{self.class.to_s} ##{id} #{"- Name: #{name}" if respond_to?('name')}"
+        elsif @has_been_replaced
+          update_record(*args)
+          logger.info "(acts_as_replaceable) Updated existing #{self.class.to_s} ##{id} #{"- Name: #{name}" if respond_to?('name')}"
         else
-          sql << "#{attribute_name} IS NULL"
+          super
+          logger.info "(acts_as_replaceable) Created #{self.class.to_s} ##{id} #{"- Name: #{name}" if respond_to?('name')}"
         end
       end
-      return [sql.join(' AND ')] + binds
+
+      return true
+    end
+
+    # Replaces self with an existing copy from the database if available, raises an exception if more than one copy exists in the database
+    def find_and_replace
+      existing = ActsAsReplaceable::HelperMethods.find_existing(self)
+
+      if existing.length > 1
+        raise RecordNotUnique, "#{existing.length} duplicate #{self.class.model_name.human.pluralize} present in database"
+      end
+
+      replace_with(existing.first) if existing.first
+    end
+
+    def replace_with(existing)
+      # Inherit target's attributes for those in acts_as_replaceable_options[:inherit]
+      ActsAsReplaceable::HelperMethods.copy_attributes(acts_as_replaceable_options[:inherit], existing, self)
+
+      @new_record        = false
+      @has_been_replaced = true
+      @has_not_changed   = !ActsAsReplaceable::HelperMethods.mark_changes(self, existing)
     end
   end
+
+  class RecordNotUnique < StandardError; end
+  class LockingUnavailable < StandardError; end
 end

data/lib/acts_as_replaceable.rb

@@ -1,3 +1,18 @@
 require 'acts_as_replaceable/acts_as_replaceable'
 
-ActiveRecord::Base.extend ActsAsReplaceable::ActMethod
+# Rails 3 compatibility
+if ActiveRecord::VERSION::MAJOR < 4
+	ActiveRecord::Base.class_eval do
+		alias_method :create_record, :create
+
+	  def create(*args)
+	    create_record(*args)
+	  end
+
+	  def update_record(*args)
+	    update(*args)
+	  end
+	end
+end
+
+ActiveRecord::Base.extend ActsAsReplaceable::ActMethod

data/spec/acts_as_replaceable_spec.rb

@@ -5,8 +5,42 @@ describe 'acts_as_dag' do
     [Material, Item, Person].each(&:destroy_all) # Because we're using sqlite3 and it doesn't support transactional specs (afaik)
   end
 
-  describe "A saved record" do
+  describe "Class methods" do
+    it "should be able to return records for which duplicates exist in the database" do
+      insert_model(Material, :name => 'glass')
+      wood1 = insert_model(Material, :name => 'wood')
+      wood2 = insert_model(Material, :name => 'wood')
+      Material.duplicates.order(:id).should == [wood1, wood2]
+    end
+  end
+
+  describe "Helper Methods" do
+    before(:each) { @record = insert_model(Material, :name => 'glass')}
 
+    it "should only allow one thread to hold the lock at a time" do
+      mutex = Mutex.new
+      counter = 0
+      expect do
+        2.times.collect do
+          Thread.new do
+            ActsAsReplaceable::HelperMethods.lock(@record) do
+              expected = mutex.synchronize { counter += 1 }
+              sleep 1 # Long enough that the other thread can try to obtain the lock while we're asleep
+              raise unless expected == counter
+            end
+          end
+        end.each(&:join)
+      end.not_to raise_exception
+    end
+
+    it "should time out execution of a lock block after a certain amount of time" do
+      expect do
+        ActsAsReplaceable::HelperMethods.lock(@record, 1.seconds) { sleep 3 }
+      end.to raise_exception(Timeout::Error)
+    end
+  end
+
+  describe "when saving a record" do
     it "should raise an exception if more than one duplicate exists in the database" do
       insert_model(Material, :name => 'wood')
       insert_model(Material, :name => 'wood')
@@ -18,7 +52,7 @@ describe 'acts_as_dag' do
       insert_model(Item, :identification_number => '1234', :holding_institution_id => 1)
       lambda {Item.create! :identification_number => '1234', :holding_institution_id => 1}.should raise_exception
     end
-    
+
     it "should replace itself with an existing record by matching a single column" do
       Material.create! :name => 'wood'
       Material.create! :name => 'wood'
@@ -45,7 +79,7 @@ describe 'acts_as_dag' do
       c.count.should == 1
       c.first.name.should == 'Dip Stick'
     end
-    
+
     it "should correctly replace an existing record when a match value is nil" do
       a = Item.create! :name => 'Stick', :identification_number => '1234', :holding_institution_id => 1
       b = Item.create! :name => 'Dip Stick', :identification_number => '1234', :holding_institution_id => 1
@@ -61,7 +95,7 @@ describe 'acts_as_dag' do
       Person.create! :first_name => 'Alanson', :last_name => 'Skinner'
       Person.where(:first_name => 'Alanson', :last_name => 'Skinner').count.should == 1
     end
-    
+
     it "should not replace an existing record with fields that were used to match" do
       Person.create! :first_name => 'joHn', :last_name => 'doE'
       Person.create! :first_name => 'John', :last_name => 'Doe'
@@ -92,5 +126,36 @@ describe 'acts_as_dag' do
       b = Material.create! :name => 'wood'
       b.persisted?.should be_true
     end
+
+    # CONCURRENCY
+
+    it "should raise an exception if concurrency is enabled but Rails.cache doesn't support the :increment method" do
+      ActsAsReplaceable.concurrency = true
+      old_cache = Rails.cache
+      Rails.cache = Object.new
+
+      begin
+        expect do
+          class TestClass < ActiveRecord::Base
+            self.table_name = Material.table_name
+            acts_as_replaceable
+          end
+        end.to raise_exception(ActsAsReplaceable::LockingUnavailable)
+      ensure
+        Rails.cache = old_cache
+      end
+    end
+
+    it "should use locking if concurrency is enabled" do
+      ActsAsReplaceable.concurrency = true
+      ActsAsReplaceable::HelperMethods.should_receive(:lock).once
+      Material.create! :name => 'wood'
+    end
+
+    it "should not use locking if concurrency is disabled" do
+      ActsAsReplaceable.concurrency = false
+      ActsAsReplaceable::HelperMethods.should_not_receive(:lock)
+      Material.create! :name => 'wood'
+    end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
 require 'active_record'
 require 'logger'
 require 'acts_as_replaceable'
@@ -15,7 +16,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.string :name
     t.string :fingerprint
   end
-  
+
   create_table :people, :force => true do |t|
     t.string :first_name
     t.string :last_name
@@ -54,4 +55,37 @@ end
 
 def insert_model(klass, attributes)
   ActiveRecord::Base.connection.execute "INSERT INTO #{klass.quoted_table_name} (#{attributes.keys.join(",")}) VALUES (#{attributes.values.collect { |value| ActiveRecord::Base.connection.quote(value) }.join(",")})", 'Fixture Insert'
-end
+  return klass.order(:id).last
+end
+
+class Rails
+  def self.cache
+    @cache ||= Cache.new
+  end
+
+  def self.cache=(cache)
+    @cache = cache
+  end
+
+  class Cache
+    def initialize
+      @lock = Mutex.new
+      @store = {}
+    end
+
+    def write(key, value, *args)
+      @lock.synchronize do
+        @store[key] = value
+      end
+    end
+
+    def increment(key, *args)
+      @lock.synchronize do
+        @store[key] = @store[key].to_i + 1
+      end
+    end
+  end
+
+  # init cache so it's there before multiple threads race to initialize it and end up with two different caches
+  self.cache
+end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_replaceable
 version: !ruby/object:Gem::Version
-  version: 1.1.1
-  prerelease: 
+  version: 1.2.0
 platform: ruby
 authors:
 - Nicholas Jakobsen
@@ -10,24 +9,28 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-03 00:00:00.000000000 Z
+date: 2013-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.2'
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - <
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 4.1.0
 description: 
 email: technical@rrnpilot.org
 executables: []
@@ -41,27 +44,26 @@ files:
 - README.rdoc
 homepage: http://github.com/rrn/acts_as_replaceable
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.1.10
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Overloads the create_or_update_without_callbacks method to allow duplicate
   records to be replaced without needing to always use find_or_create_by.
 test_files: []