mongoid-locker 1.0.1 → 2.0.0

data/lib/mongoid/locker/errors.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Locker
+    module Errors
+      # Default parent Mongoid::Locker error for all custom errors.
+      class MongoidLockerError < StandardError
+        BASE_KEY = 'mongoid.locker.errors.messages'
+
+        def initialize(key, **params)
+          message = I18n.translate("#{BASE_KEY}.#{key}.message", params)
+
+          super("\nmessage:\n  #{message}")
+        end
+      end
+
+      # Raised when a document could not be successfully locked in the database.
+      class DocumentCouldNotGetLock < MongoidLockerError
+        KEY = 'document_could_not_get_lock'
+
+        # @example Create new error.
+        #   DocumentCouldNotGetLock.new(Account, '1234')
+        #
+        # @param klass [Class] the model class
+        # @param id [String, BSON::ObjectId] the document's id
+        def initialize(klass, id)
+          super(KEY, klass: klass, id: id.to_s)
+        end
+      end
+
+      # Raised when trying to pass an invalid parameter to locker method by a class.
+      class InvalidParameter < MongoidLockerError
+        KEY = 'invalid_parameter'
+
+        # @example Create new error.
+        #   InvalidParameter.new(User, :lock_timeout)
+        #
+        # @param klass [Class] the model class
+        # @param parameter [String, Symbol] the class parameter
+        def initialize(klass, parameter)
+          super(KEY, klass: klass, parameter: parameter)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/locker/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Locker
-    VERSION = '1.0.1'.freeze
+    VERSION = '2.0.0'
   end
 end

data/lib/mongoid/locker/wrapper.rb

@@ -1,3 +1,121 @@
-raise "Incompatible Mongoid #{version} version" unless %w[4 5 6 7].include?(version = Mongoid::VERSION.split('.')[0])
+# frozen_string_literal: true
 
-require "mongoid/locker/wrapper#{version}"
+module Mongoid
+  module Locker
+    # Set of methods to interact with the database.
+    module Wrapper
+      # Finds provided document with provided options, locks (sets +locking_name_field+ and +locked_at_field+ fields), and returns the fields.
+      #
+      # @example
+      #   Mongoid::Locker::Wrapper.find_and_lock(document, opts)
+      #   #=> {"locked_at"=>2019-03-19 07:51:24 UTC, "locking_name"=>nil}
+      #
+      # @example
+      #   Mongoid::Locker::Wrapper.find_and_lock(document, opts)
+      #   # => nil
+      #
+      # @param doc [Mongoid::Document]
+      # @param opts [Hash] (see #with_lock)
+      # @return [Hash] with +locking_name_field+ and +locked_at_field+ fields
+      # @return [nil] if the document was not found, was already locked
+      def self.find_and_lock(doc, opts)
+        model = doc.class
+        filter = {
+          _id: doc.id,
+          '$or': [
+            {
+              '$or': [
+                { model.locking_name_field => { '$exists': false } },
+                { model.locked_at_field => { '$exists': false } }
+              ]
+            },
+            {
+              '$or': [
+                { model.locking_name_field => { '$eq': nil } },
+                { model.locked_at_field => { '$eq': nil } }
+              ]
+            },
+            {
+              '$where': "new Date() - this.#{model.locked_at_field} >= #{model.lock_timeout * 1000}"
+            }
+          ]
+        }
+        update = {
+          '$set': { model.locking_name_field => opts[:locking_name] },
+          '$currentDate': { model.locked_at_field => true }
+        }
+        options = {
+          return_document: :after,
+          projection: { _id: false, model.locking_name_field => true, model.locked_at_field => true },
+          write_concern: model.locker_write_concern
+        }
+
+        model.collection.find_one_and_update(filter, update, options)
+      end
+
+      # Finds provided document with provided options, unlocks (sets +locking_name_field+ and +locked_at_field+ fields to +nil+).
+      #
+      # @example
+      #   Mongoid::Locker::Wrapper.find_and_unlock(doc, opts)
+      #   #=> true
+      #   Mongoid::Locker::Wrapper.find_and_unlock(doc, opts)
+      #   #=> false
+      #
+      # @param doc [Mongoid::Document]
+      # @param opts [Hash] (see #with_lock)
+      # @return [Boolean]
+      # @return [true] if the document was unlocked
+      # @return [false] if the document was not found, was not unlocked
+      def self.find_and_unlock(doc, opts)
+        model = doc.class
+        filter = {
+          _id: doc.id,
+          model.locking_name_field => opts[:locking_name]
+        }
+        update = {
+          '$set': {
+            model.locking_name_field => nil,
+            model.locked_at_field => nil
+          }
+        }
+        options = { write_concern: model.locker_write_concern }
+
+        result = model.collection.update_one(filter, update, options)
+        result.ok? && result.written_count == 1
+      end
+
+      # Returns value of +locked_at_field+ field for provided document.
+      #
+      # @example
+      #   Mongoid::Locker::Wrapper.locked_at(document)
+      #   #=> 2019-06-03 13:50:46 UTC
+      #
+      # @param doc [Mongoid::Document]
+      # @return [Time] +locked_at_field+ field time
+      # @return [nil] if response was failed
+      def self.locked_at(doc)
+        result = doc.class.collection.find(
+          { _id: doc.id },
+          projection: { _id: false, doc.locked_at_field => true },
+          limit: 1
+        ).first
+
+        result[doc.locked_at_field.to_s] if result
+      end
+
+      # Returns the local database server time in UTC.
+      #
+      # @example
+      #   Mongoid::Locker::Wrapper.current_mongodb_time(User)
+      #   #=> 2019-03-19 07:24:36 UTC
+      #
+      # @param model [Class] the model class
+      # @return [Time] current time
+      # @return [nil] if response was failed
+      def self.current_mongodb_time(model)
+        info = model.collection.database.command(isMaster: 1)
+        info.ok? ? info.documents.first['localTime'] : nil
+      end
+    end
+  end
+end

data/mongoid-locker.gemspec

@@ -1,20 +1,22 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
 require 'mongoid/locker/version'
 
-Gem::Specification.new do |spec|
-  spec.name = 'mongoid-locker'
-  spec.version = Mongoid::Locker::VERSION
-  spec.authors = ['Aidan Feldman']
-  spec.email = ['aidan.feldman@gmail.com']
+Gem::Specification.new do |s|
+  s.name = 'mongoid-locker'
+  s.version = Mongoid::Locker::VERSION
+  s.authors = ['Aidan Feldman']
+  s.email = ['aidan.feldman@gmail.com']
 
-  spec.summary = 'Document-level locking for MongoDB via Mongoid.'
-  spec.description = 'Allows multiple processes to operate on individual documents in MongoDB while ensuring that only one can act at a time.'
-  spec.homepage = 'https://github.com/mongoid/mongoid-locker'
-  spec.license = 'MIT'
+  s.summary = 'Document-level optimistic locking for MongoDB via Mongoid.'
+  s.description = 'Allows multiple processes to operate on individual documents in MongoDB while ensuring that only one can act at a time.'
+  s.homepage = 'https://github.com/mongoid/mongoid-locker'
+  s.license = 'MIT'
 
-  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|demo)/}) }
-  spec.require_paths = ['lib']
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec)/}) }
+  s.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'mongoid', '>= 4.0', '< 8'
+  s.add_dependency 'mongoid', '>= 5.0', '< 8'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-locker
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Aidan Feldman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-23 00:00:00.000000000 Z
+date: 2019-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -38,7 +38,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".document"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -54,14 +53,12 @@ files:
 - RELEASING.md
 - Rakefile
 - UPGRADING.md
+- lib/config/locales/en.yml
 - lib/mongoid-locker.rb
 - lib/mongoid/locker.rb
+- lib/mongoid/locker/errors.rb
 - lib/mongoid/locker/version.rb
 - lib/mongoid/locker/wrapper.rb
-- lib/mongoid/locker/wrapper4.rb
-- lib/mongoid/locker/wrapper5.rb
-- lib/mongoid/locker/wrapper6.rb
-- lib/mongoid/locker/wrapper7.rb
 - mongoid-locker.gemspec
 homepage: https://github.com/mongoid/mongoid-locker
 licenses:
@@ -85,5 +82,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Document-level locking for MongoDB via Mongoid.
+summary: Document-level optimistic locking for MongoDB via Mongoid.
 test_files: []

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/lib/mongoid/locker/wrapper4.rb

@@ -1,22 +0,0 @@
-module Mongoid
-  module Locker
-    # Normalizes queries between various Mongoid versions.
-    module Wrapper
-      # Update the document for the provided Class matching the provided query with the provided setter.
-      #
-      # @param [Class] The model class
-      # @param [Hash] The Mongoid query
-      # @param [Hash] The Mongoid setter
-      # @return [Boolean] true if the document was successfully updated, false otherwise
-      def self.update(klass, query, setter)
-        klass.with(safe: true).collection.find(query).update(setter)['n'] == 1
-      end
-
-      def self.locked_until(doc)
-        existing_query = { _id: doc.id, doc.locked_until_field => { '$exists' => true } }
-        existing = doc.class.where(existing_query).limit(1).only(doc.locked_until_field).first
-        existing ? existing[doc.locked_until_field] : nil
-      end
-    end
-  end
-end

data/lib/mongoid/locker/wrapper5.rb

@@ -1,27 +0,0 @@
-module Mongoid
-  module Locker
-    # Normalizes queries between various Mongoid versions.
-    module Wrapper
-      # Update the document for the provided Class matching the provided query with the provided setter.
-      #
-      # @param [Class] The model class
-      # @param [Hash] The Mongoid query
-      # @param [Hash] The Mongoid setter
-      # @return [Boolean] true if the document was successfully updated, false otherwise
-      def self.update(klass, query, setter)
-        rc = klass.with(write: { w: 1 }).collection.find(query).update_one(setter)
-        rc.ok? && rc.documents.first['n'] == 1
-      end
-
-      # Determine whether the provided document is locked in the database or not.
-      #
-      # @param [Class] The model instance
-      # @return [Time] The timestamp of when the document is locked until, nil if not locked.
-      def self.locked_until(doc)
-        existing_query = { _id: doc.id, doc.locked_until_field => { '$exists' => true } }
-        existing = doc.class.where(existing_query).limit(1).only(doc.locked_until_field).first
-        existing ? existing[doc.locked_until_field] : nil
-      end
-    end
-  end
-end

data/lib/mongoid/locker/wrapper6.rb

@@ -1,29 +0,0 @@
-module Mongoid
-  module Locker
-    # Normalizes queries between various Mongoid versions.
-    module Wrapper
-      # Update the document for the provided Class matching the provided query with the provided setter.
-      #
-      # @param [Class] The model class
-      # @param [Hash] The Mongoid query
-      # @param [Hash] The Mongoid setter
-      # @return [Boolean] true if the document was successfully updated, false otherwise
-      def self.update(klass, query, setter)
-        rc = klass.with(write: { w: 1 }) do
-          klass.collection.find(query).update_one(setter)
-        end
-        rc.ok? && rc.documents.first['n'] == 1
-      end
-
-      # Determine whether the provided document is locked in the database or not.
-      #
-      # @param [Class] The model instance
-      # @return [Time] The timestamp of when the document is locked until, nil if not locked.
-      def self.locked_until(doc)
-        existing_query = { _id: doc.id, doc.locked_until_field => { '$exists' => true } }
-        existing = doc.class.where(existing_query).limit(1).only(doc.locked_until_field).first
-        existing ? existing[doc.locked_until_field] : nil
-      end
-    end
-  end
-end

data/lib/mongoid/locker/wrapper7.rb

@@ -1,2 +0,0 @@
-# same with wrapper6
-require 'mongoid/locker/wrapper6'