with_advisory_lock 4.0.0 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 82b0119f2158391cace745c0fa71a65497198de1
-  data.tar.gz: eb7f626ed7db658000ad0db260a2692035ee4dc1
+SHA256:
+  metadata.gz: bc4719c3f44e4cf1f219b582d21cf9757274ca1fcca6128c227798f32d4b589e
+  data.tar.gz: c63b8be1ee91b25a519b5a4d7d090ff98172d6d3a476899b55c6cd03bf77eda6
 SHA512:
-  metadata.gz: efe96bf02dc09cf167ed2058c164405c4f6d6ae9e31442b46d9e9f5ceebc7add1850861d0b6bd311087a056cab5928ad27afa680a4b11884d1474bee4ae25269
-  data.tar.gz: f9f753d910d24f6cb98fc91a47aed8dcccb82bf99f55ea193aceb8ffedf3c2732eef1c7945c64d1a5ac72aa27d89a0205307ddab72cce7113ca6c37c22496ac9
+  metadata.gz: be5a906b9740506447bfcdb1928cd5473add67e0a48acd32f8a26ca4671be49b34ca5eca987df2f8e6f29a0a3dbb0bccc3321061d9f1e5827a0ca4ef44341124
+  data.tar.gz: 124358b251ffd9cc066d54aebfeeca97fb0db88ae18293fb7e0169ceb13960d298e72c66e9d5fbd79f0cbda5360d2fdb2e609866ac82eeb26b1eab6ead103daf

data/.gitignore

@@ -17,3 +17,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.iml

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.6.4

data/.travis.yml

@@ -1,32 +1,38 @@
 language: ruby
 
-dist: trusty
-sudo: required
+services:
+  - postgresql
+  - mysql
+
+addons:
+  postgresql: "10"
 
 rvm:
-  - 2.5.1
-  - 2.4.0
-  - 2.3.3
-  - 2.2.10
+  - 2.6.4
+  - 2.5.6
+  - 2.4.7
 
 gemfile:
+  - gemfiles/activerecord_6.0.gemfile
   - gemfiles/activerecord_5.2.gemfile
   - gemfiles/activerecord_5.1.gemfile
   - gemfiles/activerecord_5.0.gemfile
   - gemfiles/activerecord_4.2.gemfile
 
 env:
-  - DB=postgresql
-  - DB=mysql
-  - DB=mysql MYSQL_VERSION=5.7
-  - DB=sqlite
+  global:
+    - WITH_ADVISORY_LOCK_PREFIX=$TRAVIS_JOB_ID
+  matrix:
+    - DB=postgresql
+    - DB=mysql MYSQL_VERSION=5.7
+    - DB=sqlite
+matrix:
+  exclude:
+    - rvm: 2.4.7
+      gemfile: gemfiles/activerecord_6.0.gemfile
 
 before_install:
-  - gem install bundler
-
-script: WITH_ADVISORY_LOCK_PREFIX=$TRAVIS_JOB_ID bundle exec rake --trace
-
-before_script:
-  - bash .travis.install-mysql-5.7.sh
   - mysql -e 'create database with_advisory_lock_test'
-  - psql -c 'create database with_advisory_lock_test' -U postgres
+  - psql -c 'create database with_advisory_lock_test' -U postgres
+
+script: bundle exec rake --trace

data/Appraisals

@@ -3,17 +3,27 @@ appraise "activerecord-4.2" do
   platforms :ruby do
       gem "pg", "~> 0.21"
       gem "mysql2", "< 0.5"
+      gem "sqlite3", "~> 1.3.6"
   end
 end
 
 appraise "activerecord-5.0" do
   gem "activerecord", "~> 5.0.0"
+  platforms :ruby do
+    gem "sqlite3", "~> 1.3.6"
+  end
 end
 
 appraise "activerecord-5.1" do
   gem "activerecord", "~> 5.1.0"
+  gem "sqlite3", "~> 1.3.6"
 end
 
 appraise "activerecord-5.2" do
   gem "activerecord", "~> 5.1.0"
-end
+  gem "sqlite3", "~> 1.3.6"
+end
+
+appraise "activerecord-6.0" do
+  gem "activerecord", "~> 6.0.0"
+end

data/CHANGELOG.md

@@ -0,0 +1,122 @@
+## Changelog
+
+### 4.6.0
+
+- Support for ActiveRecord 6
+- Add Support for nested locks in MySQL
+
+### 4.0.0
+
+- Drop support for unsupported versions of activerecord
+- Drop support for unsupported versions of ruby
+
+### 3.2.0
+
+- [Joshua Flanagan](https://github.com/joshuaflanagan) [added a SQL comment to the lock query for PostgreSQL](https://github.com/ClosureTree/with_advisory_lock/pull/28). Thanks!
+- [Fernando Luizão](https://github.com/fernandoluizao) found a spurious requirement for `thread_safe`. Thanks for the [fix](https://github.com/ClosureTree/with_advisory_lock/pull/27)!
+
+### 3.1.1
+
+- [Joel Turkel](https://github.com/jturkel) added `require 'active_support'` (it was required, but relied on downstream gems to pull in active_support before pulling in with_advisory_lock). Thanks!
+
+### 3.1.0
+
+- [Jason Weathered](https://github.com/jasoncodes) Added new shared and transaction-level lock options ([Pull request 21](https://github.com/ClosureTree/with_advisory_lock/pull/21)). Thanks!
+- Added ActiveRecord 5.0 to build matrix. Dropped 3.2, 4.0, and 4.1 (which no longer get security updates: http://rubyonrails.org/security/)
+- Replaced ruby 1.9 and 2.0 (both EOL) with ruby 2.2 and 2.3 (see https://www.ruby-lang.org/en/downloads/)
+
+### 3.0.0
+
+- Added jruby/PostgreSQL support for Rails 4.x
+- Reworked threaded tests to allow jruby tests to pass
+
+#### API changes
+
+- `yield_with_lock_and_timeout` and `yield_with_lock` now return instances of
+  `WithAdvisoryLock::Result`, so blocks that return `false` are not misinterpreted
+  as a failure to lock. As this changes the interface (albeit internal methods), the major version
+  number was incremented.
+- `with_advisory_lock_result` was introduced, which clarifies whether the lock was acquired
+  versus the yielded block returned false.
+
+### 2.0.0
+
+- Lock timeouts of 0 now attempt the lock once, as per suggested by
+  [Jon Leighton](https://github.com/jonleighton) and implemented by
+  [Abdelkader Boudih](https://github.com/seuros). Thanks to both of you!
+- [Pull request 11](https://github.com/ClosureTree/with_advisory_lock/pull/11)
+  fixed a downstream issue with jruby support! Thanks, [Aaron Todd](https://github.com/ozzyaaron)!
+- Added Travis tests for jruby
+- Dropped support for Rails 3.0, 3.1, and Ruby 1.8.7, as they are no longer
+  receiving security patches. See http://rubyonrails.org/security/ for more information.
+  This required the major version bump.
+- Refactored `advisory_lock_exists?` to use existing functionality
+- Fixed sqlite's implementation so parallel tests could be run against it
+
+### 1.0.0
+
+- Releasing 1.0.0. The interface will be stable.
+- Added `advisory_lock_exists?`. Thanks, [Sean Devine](https://github.com/barelyknown), for the
+  great pull request!
+- Added Travis test for Rails 4.1
+
+### 0.0.10
+
+- Explicitly added MIT licensing to the gemspec.
+
+### 0.0.9
+
+- Merged in Postgis Adapter Support to address [issue 7](https://github.com/ClosureTree/with_advisory_lock/issues/7)
+  Thanks for the pull request, [Abdelkader Boudih](https://github.com/seuros)!
+- The database switching code had to be duplicated by [Closure Tree](https://github.com/ClosureTree/closure_tree),
+  so I extracted a new `WithAdvisoryLock::DatabaseAdapterSupport` one-trick pony.
+- Builds were failing on Travis, so I introduced a global lock prefix that can be set with the
+  `WITH_ADVISORY_LOCK_PREFIX` environment variable. I'm not going to advertise this feature yet.
+  It's a secret. Only you and I know, now. _shhh_
+
+### 0.0.8
+
+- Addressed [issue 5](https://github.com/ClosureTree/with_advisory_lock/issues/5) by
+  using a deterministic hash for Postgresql + MRI >= 1.9.
+  Thanks for the pull request, [Joel Turkel](https://github.com/jturkel)!
+- Addressed [issue 2](https://github.com/ClosureTree/with_advisory_lock/issues/2) by
+  using a cache-busting query for MySQL and Postgres to deal with AR value caching bug.
+  Thanks for the pull request, [Jaime Giraldo](https://github.com/sposmen)!
+- Addressed [issue 4](https://github.com/ClosureTree/with_advisory_lock/issues/4) by
+  adding support for `em-postgresql-adapter`.
+  Thanks, [lestercsp](https://github.com/lestercsp)!
+
+(Hey, github—your notifications are WAY too easy to ignore!)
+
+### 0.0.7
+
+- Added Travis tests for Rails 3.0, 3.1, 3.2, and 4.0
+- Fixed MySQL bug with select_value returning a string instead of an integer when using AR 3.0.x
+
+### 0.0.6
+
+- Only require ActiveRecord >= 3.0.x
+- Fixed MySQL error reporting
+
+### 0.0.5
+
+- Asking for the currently acquired advisory lock doesn't re-ask for the lock now.
+- Introduced NestedAdvisoryLockError when asking for different, nested advisory locksMySQL
+
+### 0.0.4
+
+- Moved require into on_load, which should speed loading when AR doesn't have to spin up
+
+### 0.0.3
+
+- Fought with ActiveRecord 3.0.x and 3.1.x. You don't want them if you use threads—they fail
+  predictably.
+
+### 0.0.2
+
+- Added warning log message for nested MySQL lock calls
+- Randomized lock wait time, which can help ameliorate lock contention
+
+### 0.0.1
+
+- First whack

data/README.md

@@ -1,22 +1,27 @@
 # with_advisory_lock
 
-Adds advisory locking (mutexes) to ActiveRecord 4.2 and 5.0, with ruby 2.4, 2.3 or 2.2, when used with
-[MySQL](http://dev.mysql.com/doc/refman/5.0/en/miscellaneous-functions.html#function_get-lock)
-or [PostgreSQL](http://www.postgresql.org/docs/9.3/static/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS).
+Adds advisory locking (mutexes) to ActiveRecord 4.2, 5.x and 6.0, with ruby
+2.4, 2.5 and 2.6, when used with
+[MySQL](https://dev.mysql.com/doc/refman/8.0/en/miscellaneous-functions.html#function_get-lock)
+or
+[PostgreSQL](https://www.postgresql.org/docs/current/static/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS).
 SQLite resorts to file locking.
 
-[![Build Status](https://api.travis-ci.org/ClosureTree/with_advisory_lock.svg?branch=master)](http://travis-ci.org/ClosureTree/with_advisory_lock)
+[![Build Status](https://api.travis-ci.org/ClosureTree/with_advisory_lock.svg?branch=master)](https://travis-ci.org/ClosureTree/with_advisory_lock)
 [![Gem Version](https://badge.fury.io/rb/with_advisory_lock.svg)](https://badge.fury.io/rb/with_advisory_lock)
 
 ## What's an "Advisory Lock"?
 
-An advisory lock is a [mutex](http://en.wikipedia.org/wiki/Mutual_exclusion) used to ensure no two
-processes run some process at the same time. When the advisory lock is powered by your database
-server, as long as it isn't SQLite, your mutex spans hosts.
+An advisory lock is a [mutex](https://en.wikipedia.org/wiki/Mutual_exclusion)
+used to ensure no two processes run some process at the same time. When the
+advisory lock is powered by your database server, as long as it isn't SQLite,
+your mutex spans hosts.
 
 ## Usage
 
-Where ```User``` is an ActiveRecord model, and ```lock_name``` is some string:
+This gem automatically includes the `WithAdvisoryLock` module in all of your
+ActiveRecord models. Here's an example of how to use it where `User` is an
+ActiveRecord model, and `lock_name` is some string:
 
 ```ruby
 User.with_advisory_lock(lock_name) do
@@ -32,58 +37,65 @@ end
 
 ### Lock wait timeouts
 
-```with_advisory_lock``` takes an options hash as the second parameter.
-The ```timeout_seconds``` option defaults to ```nil```, which means wait indefinitely for the lock.
+`with_advisory_lock` takes an options hash as the second parameter. The
+`timeout_seconds` option defaults to `nil`, which means wait indefinitely for
+the lock.
 
 A value of zero will try the lock only once. If the lock is acquired, the block
-will be yielded to. If the lock is currently being held, the block will not be called.
+will be yielded to. If the lock is currently being held, the block will not be
+called.
 
-Note that if a non-nil value is provided for `timeout_seconds`, the block will not be invoked if
-the lock cannot be acquired within that time-frame.
+Note that if a non-nil value is provided for `timeout_seconds`, the block will
+not be invoked if the lock cannot be acquired within that time-frame.
 
-For backwards compatability, the timeout value can be specified directly as the second parameter.
+For backwards compatability, the timeout value can be specified directly as the
+second parameter.
 
 ### Shared locks
 
-The ```shared``` option defaults to ```false``` which means an exclusive lock will be obtained.
-Setting ```shared``` to ```true``` will allow locks to be obtained by multiple actors
-as long as they are all shared locks.
+The `shared` option defaults to `false` which means an exclusive lock will be
+obtained. Setting `shared` to `true` will allow locks to be obtained by multiple
+actors as long as they are all shared locks.
 
 Note: MySQL does not support shared locks.
 
 ### Transaction-level locks
 
-PostgreSQL supports transaction-level locks which remain held until the transaction completes.
-You can enable this by setting the ```transaction``` option to ```true```.
+PostgreSQL supports transaction-level locks which remain held until the
+transaction completes. You can enable this by setting the `transaction` option
+to `true`.
 
-Note: transaction-level locks will not be reflected by `.current_advisory_lock` when the block has returned.
+Note: transaction-level locks will not be reflected by `.current_advisory_lock`
+when the block has returned.
 
 ### Return values
 
-The return value of `with_advisory_lock_result` is a `WithAdvisoryLock::Result` instance,
-which has a `lock_was_acquired?` method and a `result` accessor method, which is
-the returned value of the given block. If your block may validly return false, you should use
-this method.
- 
-The return value of ```with_advisory_lock``` will be the result of the yielded block,
-if the lock was able to be acquired and the block yielded, or ```false```, if you provided
-a timeout_seconds value and the lock was not able to be acquired in time.
+The return value of `with_advisory_lock_result` is a `WithAdvisoryLock::Result`
+instance, which has a `lock_was_acquired?` method and a `result` accessor
+method, which is the returned value of the given block. If your block may
+validly return false, you should use this method.
+
+The return value of `with_advisory_lock` will be the result of the yielded
+block, if the lock was able to be acquired and the block yielded, or `false`, if
+you provided a timeout_seconds value and the lock was not able to be acquired in
+time.
 
 ### Testing for the current lock status
 
-If you needed to check if the advisory lock is currently being held, you can call
-```Tag.advisory_lock_exists?("foo")```, but realize the lock can be acquired between the time you
-test for the lock, and the time you try to acquire the lock.
+If you needed to check if the advisory lock is currently being held, you can
+call `Tag.advisory_lock_exists?("foo")`, but realize the lock can be acquired
+between the time you test for the lock, and the time you try to acquire the
+lock.
 
-If you want to see if the current Thread is holding a lock, you can call ```Tag.current_advisory_lock```
-which will return the name of the current lock. If no lock is currently held,
-```.current_advisory_lock``` returns ```nil```.
+If you want to see if the current Thread is holding a lock, you can call
+`Tag.current_advisory_lock` which will return the name of the current lock. If
+no lock is currently held, `.current_advisory_lock` returns `nil`.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-``` ruby
+```ruby
 gem 'with_advisory_lock'
 ```
 
@@ -93,27 +105,31 @@ And then execute:
 
 ## Lock Types
 
-First off, know that there are **lots** of different kinds of locks available to you. **Pick the
-finest-grain lock that ensures correctness.** If you choose a lock that is too coarse, you are
-unnecessarily blocking other processes.
+First off, know that there are **lots** of different kinds of locks available to
+you. **Pick the finest-grain lock that ensures correctness.** If you choose a
+lock that is too coarse, you are unnecessarily blocking other processes.
 
 ### Advisory locks
-These are named mutexes that are inherently "application level"—it is up to the application
-to acquire, run a critical code section, and release the advisory lock.
+
+These are named mutexes that are inherently "application level"—it is up to the
+application to acquire, run a critical code section, and release the advisory
+lock.
 
 ### Row-level locks
+
 Whether [optimistic](http://api.rubyonrails.org/classes/ActiveRecord/Locking/Optimistic.html)
 or [pessimistic](http://api.rubyonrails.org/classes/ActiveRecord/Locking/Pessimistic.html),
 row-level locks prevent concurrent modification to a given model.
 
 **If you're building a
-[CRUD](http://en.wikipedia.org/wiki/Create,_read,_update_and_delete) application, this will be your
-most commonly used lock.**
+[CRUD](http://en.wikipedia.org/wiki/Create,_read,_update_and_delete)
+application, this will be your most commonly used lock.**
 
 ### Table-level locks
 
-Provided through something like the [monogamy](https://github.com/ClosureTree/monogamy)
-gem, these prevent concurrent access to **any instance of a model**. Their coarseness means they
+Provided through something like the
+[monogamy](https://github.com/ClosureTree/monogamy) gem, these prevent
+concurrent access to **any instance of a model**. Their coarseness means they
 aren't going to be commonly applicable, and they can be a source of
 [deadlocks](http://en.wikipedia.org/wiki/Deadlock).
 
@@ -125,26 +141,31 @@ Advisory locks with MySQL and PostgreSQL ignore database transaction boundaries.
 
 You will want to wrap your block within a transaction to ensure consistency.
 
-### MySQL doesn't support nesting
+### MySQL < 5.7.5 doesn't support nesting
+
+With MySQL < 5.7.5, if you ask for a _different_ advisory lock within
+a `with_advisory_lock` block, you will be releasing the parent lock (!!!). A
+`NestedAdvisoryLockError`will be raised in this case. If you ask for the same
+lock name, `with_advisory_lock` won't ask for the lock again, and the block
+given will be yielded to.
 
-With MySQL (at least <= v5.5), if you ask for a *different* advisory lock within a ```with_advisory_lock``` block,
-you will be releasing the parent lock (!!!). A ```NestedAdvisoryLockError```will be raised
-in this case. If you ask for the same lock name, ```with_advisory_lock``` won't ask for the
-lock again, and the block given will be yielded to.
+This is not an issue in MySQL >= 5.7.5, and no error will be raised for nested
+lock usage. You can override this by passing `force_nested_lock_support: true`
+or `force_nested_lock_support: false` to the `with_advisory_lock` options.
 
 ### Is clustered MySQL supported?
 
 [No.](https://github.com/ClosureTree/with_advisory_lock/issues/16)
 
-### There are many ```lock-*``` files in my project directory after test runs
+### There are many `lock-*` files in my project directory after test runs
 
 This is expected if you aren't using MySQL or Postgresql for your tests.
 See [issue 3](https://github.com/ClosureTree/with_advisory_lock/issues/3).
 
-SQLite doesn't have advisory locks, so we resort to file locking, which will only work
-if the ```FLOCK_DIR``` is set consistently for all ruby processes.
+SQLite doesn't have advisory locks, so we resort to file locking, which will
+only work if the `FLOCK_DIR` is set consistently for all ruby processes.
 
-In your ```spec_helper.rb``` or ```minitest_helper.rb```, add a ```before``` and ```after``` block:
+In your `spec_helper.rb` or `minitest_helper.rb`, add a `before` and `after` block:
 
 ```ruby
 before do
@@ -155,121 +176,3 @@ after do
   FileUtils.remove_entry_secure ENV['FLOCK_DIR']
 end
 ```
-
-## Changelog
-
-### 4.0.0
-
-* Drop support for unsupported versions of activerecord
-* Drop support for unsupported versions of ruby
-
-### 3.2.0
-
-* [Joshua Flanagan](https://github.com/joshuaflanagan) [added a SQL comment to the lock query for PostgreSQL](https://github.com/ClosureTree/with_advisory_lock/pull/28). Thanks!
-* [Fernando Luizão](https://github.com/fernandoluizao) found a spurious requirement for `thread_safe`. Thanks for the [fix](https://github.com/ClosureTree/with_advisory_lock/pull/27)!
-
-### 3.1.1
-
-* [Joel Turkel](https://github.com/jturkel) added `require 'active_support'` (it was required, but relied on downstream gems to pull in active_support before pulling in with_advisory_lock). Thanks!
-
-### 3.1.0
-
-* [Jason Weathered](https://github.com/jasoncodes) Added new shared and transaction-level lock options ([Pull request 21](https://github.com/ClosureTree/with_advisory_lock/pull/21)). Thanks!
-* Added ActiveRecord 5.0 to build matrix. Dropped 3.2, 4.0, and 4.1 (which no longer get security updates: http://rubyonrails.org/security/)
-* Replaced ruby 1.9 and 2.0 (both EOL) with ruby 2.2 and 2.3 (see https://www.ruby-lang.org/en/downloads/)
-
-### 3.0.0
-
-* Added jruby/PostgreSQL support for Rails 4.x 
-* Reworked threaded tests to allow jruby tests to pass
-
-#### API changes
-
-* `yield_with_lock_and_timeout` and `yield_with_lock` now return instances of
-  `WithAdvisoryLock::Result`, so blocks that return `false` are not misinterpreted
-  as a failure to lock. As this changes the interface (albeit internal methods), the major version
-  number was incremented.
-* `with_advisory_lock_result` was introduced, which clarifies whether the lock was acquired
-  versus the yielded block returned false.  
- 
-### 2.0.0
-
-* Lock timeouts of 0 now attempt the lock once, as per suggested by 
-  [Jon Leighton](https://github.com/jonleighton) and implemented by 
-  [Abdelkader Boudih](https://github.com/seuros). Thanks to both of you!
-* [Pull request 11](https://github.com/ClosureTree/with_advisory_lock/pull/11) 
-  fixed a downstream issue with jruby support! Thanks, [Aaron Todd](https://github.com/ozzyaaron)!
-* Added Travis tests for jruby
-* Dropped support for Rails 3.0, 3.1, and Ruby 1.8.7, as they are no longer
-  receiving security patches. See http://rubyonrails.org/security/ for more information. 
-  This required the major version bump.
-* Refactored `advisory_lock_exists?` to use existing functionality
-* Fixed sqlite's implementation so parallel tests could be run against it 
-
-### 1.0.0
-
-* Releasing 1.0.0. The interface will be stable.
-* Added ```advisory_lock_exists?```. Thanks, [Sean Devine](https://github.com/barelyknown), for the
-  great pull request!
-* Added Travis test for Rails 4.1
-
-### 0.0.10
-
-* Explicitly added MIT licensing to the gemspec.
-
-### 0.0.9
-
-* Merged in Postgis Adapter Support to address [issue 7](https://github.com/ClosureTree/with_advisory_lock/issues/7)
-  Thanks for the pull request, [Abdelkader Boudih](https://github.com/seuros)!
-* The database switching code had to be duplicated by [Closure Tree](https://github.com/ClosureTree/closure_tree),
-  so I extracted a new ```WithAdvisoryLock::DatabaseAdapterSupport``` one-trick pony.
-* Builds were failing on Travis, so I introduced a global lock prefix that can be set with the
-  ```WITH_ADVISORY_LOCK_PREFIX``` environment variable. I'm not going to advertise this feature yet.
-  It's a secret. Only you and I know, now. *shhh*
-
-### 0.0.8
-
-* Addressed [issue 5](https://github.com/ClosureTree/with_advisory_lock/issues/5) by
-  using a deterministic hash for Postgresql + MRI >= 1.9.
-  Thanks for the pull request, [Joel Turkel](https://github.com/jturkel)!
-* Addressed [issue 2](https://github.com/ClosureTree/with_advisory_lock/issues/2) by
-  using a cache-busting query for MySQL and Postgres to deal with AR value caching bug.
-  Thanks for the pull request, [Jaime Giraldo](https://github.com/sposmen)!
-* Addressed [issue 4](https://github.com/ClosureTree/with_advisory_lock/issues/4) by
-  adding support for ```em-postgresql-adapter```.
-  Thanks, [lestercsp](https://github.com/lestercsp)!
-
-(Hey, github—your notifications are WAY too easy to ignore!)
-
-### 0.0.7
-
-* Added Travis tests for Rails 3.0, 3.1, 3.2, and 4.0
-* Fixed MySQL bug with select_value returning a string instead of an integer when using AR 3.0.x
-
-### 0.0.6
-
-* Only require ActiveRecord >= 3.0.x
-* Fixed MySQL error reporting
-
-### 0.0.5
-
-* Asking for the currently acquired advisory lock doesn't re-ask for the lock now.
-* Introduced NestedAdvisoryLockError when asking for different, nested advisory locksMySQL
-
-### 0.0.4
-
-* Moved require into on_load, which should speed loading when AR doesn't have to spin up
-
-### 0.0.3
-
-* Fought with ActiveRecord 3.0.x and 3.1.x. You don't want them if you use threads—they fail
-  predictably.
-
-### 0.0.2
-
-* Added warning log message for nested MySQL lock calls
-* Randomized lock wait time, which can help ameliorate lock contention
-
-### 0.0.1
-
-* First whack

data/gemfiles/activerecord_4.2.gemfile

@@ -7,7 +7,7 @@ gem "activerecord", "~> 4.2.0"
 platforms :ruby do
   gem "mysql2", "< 0.5"
   gem "pg", "~> 0.21"
-  gem "sqlite3"
+  gem "sqlite3", "~> 1.3.6"
 end
 
 platforms :jruby do

data/gemfiles/activerecord_5.0.gemfile

@@ -7,7 +7,7 @@ gem "activerecord", "~> 5.0.0"
 platforms :ruby do
   gem "mysql2"
   gem "pg"
-  gem "sqlite3"
+  gem "sqlite3", "~> 1.3.6"
 end
 
 platforms :jruby do

data/gemfiles/activerecord_5.1.gemfile

@@ -7,7 +7,7 @@ gem "activerecord", "~> 5.1.0"
 platforms :ruby do
   gem "mysql2"
   gem "pg"
-  gem "sqlite3"
+  gem "sqlite3", "~> 1.3.6"
 end
 
 platforms :jruby do

data/gemfiles/activerecord_5.2.gemfile

@@ -7,7 +7,7 @@ gem "activerecord", "~> 5.1.0"
 platforms :ruby do
   gem "mysql2"
   gem "pg"
-  gem "sqlite3"
+  gem "sqlite3", "~> 1.3.6"
 end
 
 platforms :jruby do

data/gemfiles/activerecord_6.0.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 6.0.0"
+
+platforms :ruby do
+  gem "mysql2"
+  gem "pg"
+  gem "sqlite3"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbcmysql-adapter"
+  gem "activerecord-jdbcpostgresql-adapter"
+  gem "activerecord-jdbcsqlite3-adapter"
+end
+
+gemspec path: "../"

data/lib/with_advisory_lock.rb

@@ -9,6 +9,7 @@ module WithAdvisoryLock
   autoload :DatabaseAdapterSupport
   autoload :Flock
   autoload :MySQL, 'with_advisory_lock/mysql'
+  autoload :MySQLNoNesting, 'with_advisory_lock/mysql_no_nesting'
   autoload :NestedAdvisoryLockError
   autoload :PostgreSQL, 'with_advisory_lock/postgresql'
 end

data/lib/with_advisory_lock/concern.rb

@@ -12,7 +12,8 @@ module WithAdvisoryLock
       end
 
       def with_advisory_lock_result(lock_name, options = {}, &block)
-        impl = impl_class.new(connection, lock_name, options)
+        class_options = options.extract!(:force_nested_lock_support) if options.respond_to?(:fetch)
+        impl = impl_class(class_options).new(connection, lock_name, options)
         impl.with_advisory_lock_if_needed(&block)
       end
 
@@ -28,12 +29,22 @@ module WithAdvisoryLock
 
       private
 
-      def impl_class
+      def impl_class(options = nil)
         adapter = WithAdvisoryLock::DatabaseAdapterSupport.new(connection)
         if adapter.postgresql?
           WithAdvisoryLock::PostgreSQL
         elsif adapter.mysql?
-          WithAdvisoryLock::MySQL
+          nested_lock = if options.respond_to?(:fetch) && [true, false].include?(options.fetch(:force_nested_lock_support, nil))
+                          options.fetch(:force_nested_lock_support)
+                        else
+                          adapter.mysql_nested_lock_support?
+                        end
+
+          if nested_lock
+            WithAdvisoryLock::MySQL
+          else
+            WithAdvisoryLock::MySQLNoNesting
+          end
         else
           WithAdvisoryLock::Flock
         end

data/lib/with_advisory_lock/database_adapter_support.rb

@@ -1,13 +1,57 @@
 module WithAdvisoryLock
   class DatabaseAdapterSupport
+    # Caches nested lock support by MySQL reported version
+    @@mysql_nl_cache       = {}
+    @@mysql_nl_cache_mutex = Mutex.new
+
     def initialize(connection)
-      @sym_name = connection.adapter_name.downcase.to_sym
+      @connection = connection
+      @sym_name   = connection.adapter_name.downcase.to_sym
     end
 
     def mysql?
       %i[mysql mysql2].include? @sym_name
     end
 
+    # Nested lock support for MySQL was introduced in 5.7.5
+    # Checking by version number is complicated by MySQL compatible DBs (like MariaDB) having their own versioning schemes
+    # Therefore, we check for nested lock support by simply trying a nested lock, then testing and caching the outcome
+    def mysql_nested_lock_support?
+      return false unless mysql?
+
+      # We select the MySQL version this way and cache on it, as MySQL will report versions like "5.7.5", and MariaDB will
+      # report versions like "10.3.8-MariaDB", which allow us to cache on features without introducing problems.
+      version = @connection.select_value("SELECT version()")
+
+      @@mysql_nl_cache_mutex.synchronize do
+        return @@mysql_nl_cache[version] if @@mysql_nl_cache.keys.include?(version)
+
+        lock_1 = "\"nested-test-1-#{SecureRandom.hex}\""
+        lock_2 = "\"nested-test-2-#{SecureRandom.hex}\""
+
+        get_1  = @connection.select_value("SELECT GET_LOCK(#{lock_1}, 0) AS t#{SecureRandom.hex}")
+        get_2  = @connection.select_value("SELECT GET_LOCK(#{lock_2}, 0) AS t#{SecureRandom.hex}")
+
+        # Both locks should succeed in old and new MySQL versions with "1"
+        raise RuntimeError, "Unexpected nested lock acquire result #{get_1}, #{get_2}" unless [get_1, get_2] == [1, 1]
+
+        release_1 = @connection.select_value("SELECT RELEASE_LOCK(#{lock_1}) AS t#{SecureRandom.hex}")
+        release_2 = @connection.select_value("SELECT RELEASE_LOCK(#{lock_2}) AS t#{SecureRandom.hex}")
+
+        # In MySQL <  5.7.5 release_1 will return  nil (not currently locked) and release_2 will return 1 (successfully unlocked)
+        # In MySQL >= 5.7.5 release_1 and release_2 will return 1 (both successfully unlocked)
+        # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock for more
+        @@mysql_nl_cache[version] = case [release_1, release_2]
+                                    when [1, 1]
+                                      true
+                                    when [nil, 1]
+                                      false
+                                    else
+                                      raise RuntimeError, "Unexpected nested lock release result #{release_1}, #{release_2}"
+                                    end
+      end
+    end
+
     def postgresql?
       %i[postgresql empostgresql postgis].include? @sym_name
     end

data/lib/with_advisory_lock/mysql.rb

@@ -1,13 +1,8 @@
 module WithAdvisoryLock
+  # MySQL > 5.7.5 supports nested locks
   class MySQL < Base
-    # See http://dev.mysql.com/doc/refman/5.0/en/miscellaneous-functions.html#function_get-lock
+    # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock
     def try_lock
-      unless lock_stack.empty?
-        raise NestedAdvisoryLockError.new(
-          "MySQL doesn't support nested Advisory Locks",
-          lock_stack.dup
-        )
-      end
       raise ArgumentError, 'shared locks are not supported on MySQL' if shared
       if transaction
         raise ArgumentError, 'transaction level locks are not supported on MySQL'
@@ -24,11 +19,6 @@ module WithAdvisoryLock
       connection.select_value(sql).to_i > 0
     end
 
-    # MySQL doesn't support nested locks:
-    def already_locked?
-      lock_stack.last == lock_stack_item
-    end
-
     # MySQL wants a string as the lock key.
     def quoted_lock_str
       connection.quote(lock_str)

data/lib/with_advisory_lock/mysql_no_nesting.rb

@@ -0,0 +1,20 @@
+module WithAdvisoryLock
+  # For MySQL < 5.7.5 that does not support nested locks
+  class MySQLNoNesting < MySQL
+    # See http://dev.mysql.com/doc/refman/5.0/en/miscellaneous-functions.html#function_get-lock
+    def try_lock
+      unless lock_stack.empty?
+        raise NestedAdvisoryLockError.new(
+          "MySQL < 5.7.5 doesn't support nested Advisory Locks",
+          lock_stack.dup
+        )
+      end
+      super
+    end
+
+    # MySQL doesn't support nested locks:
+    def already_locked?
+      lock_stack.last == lock_stack_item
+    end
+  end
+end

data/lib/with_advisory_lock/version.rb

@@ -1,3 +1,3 @@
 module WithAdvisoryLock
-  VERSION = Gem::Version.new('4.0.0')
+  VERSION = Gem::Version.new('4.6.0')
 end

data/test/nesting_test.rb

@@ -25,8 +25,8 @@ describe "lock nesting" do
     impl.lock_stack.must_be_empty
   end
 
-  it "raises errors with MySQL when acquiring nested lock" do
-    skip unless env_db == :mysql
+  it "raises errors with MySQL < 5.7.5 when acquiring nested lock" do
+    skip unless env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
     exc = proc {
       Tag.with_advisory_lock("first") do
         Tag.with_advisory_lock("second") do
@@ -36,8 +36,30 @@ describe "lock nesting" do
     exc.lock_stack.map(&:name).must_equal %w(first)
   end
 
-  it "supports nested advisory locks with !MySQL" do
-    skip if env_db == :mysql
+  it "does not raise errors with MySQL < 5.7.5 when acquiring nested error force enabled" do
+    skip unless env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
+    impl = WithAdvisoryLock::Base.new(nil, nil, nil)
+    impl.lock_stack.must_be_empty
+    Tag.with_advisory_lock("first", force_nested_lock_support: true) do
+      impl.lock_stack.map(&:name).must_equal %w(first)
+      Tag.with_advisory_lock("second", force_nested_lock_support: true) do
+        impl.lock_stack.map(&:name).must_equal %w(first second)
+        Tag.with_advisory_lock("first", force_nested_lock_support: true) do
+          # Shouldn't ask for another lock:
+          impl.lock_stack.map(&:name).must_equal %w(first second)
+          Tag.with_advisory_lock("second", force_nested_lock_support: true) do
+            # Shouldn't ask for another lock:
+            impl.lock_stack.map(&:name).must_equal %w(first second)
+          end
+        end
+      end
+      impl.lock_stack.map(&:name).must_equal %w(first)
+    end
+    impl.lock_stack.must_be_empty
+  end
+
+  it "supports nested advisory locks with !MySQL 5.6" do
+    skip if env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
     impl = WithAdvisoryLock::Base.new(nil, nil, nil)
     impl.lock_stack.must_be_empty
     Tag.with_advisory_lock("first") do
@@ -57,4 +79,15 @@ describe "lock nesting" do
     end
     impl.lock_stack.must_be_empty
   end
+
+  it "raises with !MySQL 5.6 and nested error force disabled" do
+    skip unless env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
+    exc = proc {
+      Tag.with_advisory_lock("first", force_nested_lock_support: false) do
+        Tag.with_advisory_lock("second", force_nested_lock_support: false) do
+        end
+      end
+    }.must_raise WithAdvisoryLock::NestedAdvisoryLockError
+    exc.lock_stack.map(&:name).must_equal %w(first)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: with_advisory_lock
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.6.0
 platform: ruby
 authors:
 - Matthew McEachen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-04 00:00:00.000000000 Z
+date: 2019-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -116,9 +116,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".travis.install-mysql-5.7.sh"
+- ".tool-versions"
 - ".travis.yml"
 - Appraisals
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -127,12 +128,14 @@ files:
 - gemfiles/activerecord_5.0.gemfile
 - gemfiles/activerecord_5.1.gemfile
 - gemfiles/activerecord_5.2.gemfile
+- gemfiles/activerecord_6.0.gemfile
 - lib/with_advisory_lock.rb
 - lib/with_advisory_lock/base.rb
 - lib/with_advisory_lock/concern.rb
 - lib/with_advisory_lock/database_adapter_support.rb
 - lib/with_advisory_lock/flock.rb
 - lib/with_advisory_lock/mysql.rb
+- lib/with_advisory_lock/mysql_no_nesting.rb
 - lib/with_advisory_lock/nested_advisory_lock_error.rb
 - lib/with_advisory_lock/postgresql.rb
 - lib/with_advisory_lock/version.rb
@@ -168,8 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Advisory locking for ActiveRecord

data/.travis.install-mysql-5.7.sh

@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-if [[ "${MYSQL_VERSION}" == "5.7" ]]; then
-  sudo service mysql stop || echo "mysql not stopped"
-  sudo stop mysql-5.6 || echo "mysql-5.6 not stopped"
-  echo mysql-apt-config mysql-apt-config/select-server select mysql-5.7 | sudo debconf-set-selections
-  wget http://dev.mysql.com/get/mysql-apt-config_0.7.3-1_all.deb
-  sudo dpkg --install mysql-apt-config_0.7.3-1_all.deb
-  sudo apt-get update -q
-  sudo apt-get install -q -y --allow-unauthenticated -o Dpkg::Options::=--force-confnew mysql-server
-  sudo mysql_upgrade
-fi