DynamoidLockable

gem 'dynamoid_lockable'

class MyModel
  include Dynamoid::Document
  include DynamoidLockable

  # Models may have more than one lock discriminated by name.
  # Creates a lock named :importing, which locks by default for 5 minutes and will refresh the lock every 10 seconds.
  # Default values:
  #  lock_for: 10 minutes
  #  relock_every: 1/3 of lock_for
  locks_with :importing, lock_for: 5 * 60, relock_every: 10
end

thing = MyModel.find('abcd')

# Most basic usage
thing.perform_with_lock(:importing) do
  # do whatever you like in here, record will remain locked as long as this block is executing and the
  # thread is able to do work
end

# Manually locking and unlocking
thing.lock(:importing)
# WARNING! Lock is not persisted, you have 5 minutes to complete your task
do_work(thing)
thing.unlock(:importing)

# You can also search by entities which are lockable (unlocked, locks expired or eleigible for reentry)
search = MyModel.lockable(:importing).first

# Note that `lockable` returns a dynamoid_advanced_where chain, so additional where clauses may be appended

# Locks support reentry from the same thread
thing.lock(:importing)
thing.lock(:importing) # No error

Thread.new do
  thing.lock(:importing) # Error: DynamoidLockable::CouldNotAcquireLock
end

describe 'locking works' do
  before do
    my_object.lock(:thing_in_progress, locker_name: 'tEsT_lOcKeR_nAmE')
  end

  it 'never calls some method that needs to acquire the lock' do
    expect(job).not_to receive(:my_locked_method!)
    job.perform
  end
end

describe 'locking works' do
  around do |ex|
    my_object.perform_with_lock(:thing_in_progress) { ex.run }
  end

  it 'never calls some method that needs to acquire the lock' do
    expect(job).not_to receive(:my_locked_method!)
    Thread.new { job.perform }.join # spawn a thread, call your job method, then join the thread
  end
end