mimi-db 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c53122867fbeeebb2deb1484c383ecf659b4d3c
-  data.tar.gz: 6202ee4865efc7d314125eca122c30d797d71706
+  metadata.gz: 9aec6438056a412a0d1807eb550ecae64eea936e
+  data.tar.gz: 7abc14cb1ee6040f9af0f5dc0852fd464c5a1f2e
 SHA512:
-  metadata.gz: 478721eb8fe5faf6dbe3144b939bf2a925e76e0a647e0b58f1a569e01dc7d0d012c0db4df858511a39f713fca0ed29b82f21024c240029fe52a49021792c1151
-  data.tar.gz: b82fa58eb333e264e804b3bdf14e94474856758f2e9df6fba1f0659b2f8f3a42af0a2d118003b15a8337b551adc89e503c19e04277273107452fe565f85be2a3
+  metadata.gz: a67de7fe7f9d7cf7c6785b8de1bf8cbfdeaf96bcf99a5957f56828f4111c683f090e88ef3ba658319685e650d573b2d7da07664c5efb6f9c98beb322631391e3
+  data.tar.gz: d339acb6afd0affa0b6905eab0502f97801adc3e6c460300d3502725395e53bcd843a7808e74d1e0070a63c7e850eda01ccb704ee9e7235c1f9d09670ec136b7

data/lib/mimi/db/helpers.rb

@@ -0,0 +1,53 @@
+module Mimi
+  module DB
+    module Helpers
+      #
+      # Returns a list of model classes
+      #
+      # @return [Array<ActiveRecord::Base>]
+      #
+      def models
+        ActiveRecord::Base.descendants
+      end
+
+      # Migrates the schema for known models
+      #
+      def migrate_schema!
+        models.each(&:auto_upgrade!)
+      end
+
+      # Creates the database specified in the current configuration.
+      #
+      def create!
+        ActiveRecord::Tasks::DatabaseTasks.root = Mimi.app_root_path
+        ActiveRecord::Tasks::DatabaseTasks.create(Mimi::DB.active_record_config)
+      end
+
+      # Drops the database specified in the current configuration.
+      #
+      def drop!
+        ActiveRecord::Tasks::DatabaseTasks.root = Mimi.app_root_path
+        ActiveRecord::Tasks::DatabaseTasks.drop(Mimi::DB.active_record_config)
+      end
+
+      # Clears (but not drops) the database specified in the current configuration.
+      #
+      def clear!
+        ActiveRecord::Tasks::DatabaseTasks.root = Mimi.app_root_path
+        ActiveRecord::Tasks::DatabaseTasks.purge(Mimi::DB.active_record_config)
+      end
+
+      # Executes raw SQL, with variables interpolation.
+      #
+      # @example
+      #   Mimi::DB.execute('insert into table1 values(?, ?, ?)', 'foo', :bar, 123)
+      #
+      def execute(statement, *args)
+        sql = ActiveRecord::Base.send(:replace_bind_variables, statement, args)
+        ActiveRecord::Base.connection.execute(sql)
+      end
+    end # module Helpers
+
+    extend Mimi::DB::Helpers
+  end # module DB
+end # module Mimi

data/lib/mimi/db/lock/mysql_lock.rb

@@ -0,0 +1,56 @@
+module Mimi
+  module DB
+    module Lock
+      class MysqlLock
+        attr_reader :name, :name_uint64, :options, :timeout
+
+        #
+        # Timeout semantics:
+        # nil -- wait indefinitely
+        # 0   -- do not wait
+        # <s> -- wait <s> seconds (can be Float)
+        #
+        def initialize(name, opts = {})
+          @name = name
+          @name_uint64 = Digest::SHA1.digest(name).unpack('q').first
+          @options = opts
+          @timeout =
+            if opts[:timeout].nil?
+              -1
+            elsif opts[:timeout] <= 0
+              0
+            else
+              opts[:timeout].to_f.round
+            end
+        end
+
+        def execute(&_block)
+          ActiveRecord::Base.transaction(requires_new: true) do
+            begin
+              acquire_lock_with_timeout!
+              yield if block_given?
+            ensure
+              release_lock!
+            end
+          end
+        end
+
+        private
+
+        #
+        def acquire_lock_with_timeout!
+          result = Mimi::DB.execute('select get_lock(?, ?) as lock_acquired', name, timeout)
+          lock_acquired = result.first[0] == 1
+          raise Mimi::DB::Lock::NotAvailable unless lock_acquired
+          true
+        end
+
+        #
+        def release_lock!
+          Mimi::DB.execute('select release_lock(?)', name)
+          true
+        end
+      end # class MysqlLock
+    end # module Lock
+  end # module DB
+end # module Mimi

data/lib/mimi/db/lock/postgresql_lock.rb

@@ -0,0 +1,84 @@
+module Mimi
+  module DB
+    module Lock
+      class PostgresqlLock
+        attr_reader :name, :name_uint64, :options, :timeout
+
+        #
+        # Timeout semantics:
+        # nil -- wait indefinitely
+        # 0   -- do not wait
+        # <s> -- wait <s> seconds (can be Float)
+        #
+        def initialize(name, opts = {})
+          @name = name
+          @name_uint64 = Digest::SHA1.digest(name).unpack('q').first
+          @options = opts
+          @timeout =
+            if opts[:timeout].nil?
+              0
+            elsif opts[:timeout] <= 0
+              :nowait
+            else
+              opts[:timeout]
+            end
+        end
+
+        def execute(&_block)
+          ActiveRecord::Base.transaction(requires_new: true) do
+            acquire_lock_with_timeout!
+            yield if block_given?
+          end
+        end
+
+        private
+
+        # Returns current database connection setting for the lock timeout.
+        # Value of 0 means the lock timeout is not set.
+        #
+        # @return [Float] Lock timeout in seconds
+        #
+        def lock_timeout
+          result = Mimi::DB.execute('select setting from pg_settings where name = ?', :lock_timeout)
+          value = result.first['setting'].to_i
+          value = value.to_f / 1000 unless value == 0
+          value
+        end
+
+        # Sets the current database connection setting for the lock timeout.
+        # Value of 0 means the lock operations should never timeout.
+        #
+        # @param [Float,Fixnum] value Lock timeout in seconds
+        #
+        def lock_timeout=(value)
+          raise ArgumentError, 'Numeric value expected as timeout' unless value.is_a?(Numeric)
+          value = (value * 1000).to_i
+          Mimi::DB.execute('update pg_settings set setting = ? where name = ?', value, :lock_timeout)
+        end
+
+        #
+        def acquire_lock_with_timeout!
+          unless timeout == :nowait
+            old_timeout = lock_timeout
+            self.lock_timeout = timeout unless timeout == old_timeout
+          end
+          if timeout == :nowait
+            result = Mimi::DB.execute('select pg_try_advisory_xact_lock(?) as lock_acquired', name_uint64)
+            lock_acquired = result.first['lock_acquired'] == 't'
+            raise Mimi::DB::Lock::NotAvailable unless lock_acquired
+          else
+            begin
+              Mimi::DB.execute('select pg_advisory_xact_lock(?)', name_uint64)
+            rescue ActiveRecord::StatementInvalid
+              raise Mimi::DB::Lock::NotAvailable
+            end
+            # NOTE: in case of a timeout the lock_timeout value will not be set back manually
+            # .. it is expected to roll back with the transaction
+            self.lock_timeout = old_timeout unless timeout == old_timeout
+          end
+          true
+        end
+      end # class PostgresqlLock
+    end # module Lock
+  end # module DB
+end # module Mimi

data/lib/mimi/db/lock/sqlite_lock.rb

@@ -0,0 +1,72 @@
+require 'filelock'
+
+module Mimi
+  module DB
+    module Lock
+      class SqliteLock
+        attr_reader :name, :name_digest, :lock_filename, :options, :timeout
+
+        #
+        # Timeout semantics:
+        # nil -- wait indefinitely
+        # 0   -- do not wait
+        # <s> -- wait <s> seconds (can be Float)
+        #
+        def initialize(name, opts = {})
+          @name = name
+          @name_digest = Digest::SHA1.hexdigest(name).first(16)
+          @options = opts
+          @timeout =
+            if opts[:timeout].nil?
+              -1
+            elsif opts[:timeout] <= 0
+              0.100
+            else
+              opts[:timeout].to_f.round
+            end
+          db_filename = Pathname.new(Mimi::DB.module_options[:db_database]).expand_path
+          @lock_filename = "#{db_filename}.lock-#{name_digest}"
+          @lock_acquired = nil
+          @file = nil
+        end
+
+        def execute(&_block)
+          ActiveRecord::Base.transaction(requires_new: true) do
+            begin
+              acquire_lock_with_timeout!
+              yield if block_given?
+            ensure
+              release_lock!
+            end
+          end
+        end
+
+        private
+
+        #
+        def acquire_lock_with_timeout!
+          Mimi::DB.logger.info "! Locking file: #{lock_filename}"
+
+          @file = File.open(lock_filename, File::RDWR | File::CREAT, 0644)
+          if timeout
+            Timeout.timeout(timeout, Mimi::DB::Lock::NotAvailable) { @file.flock(File::LOCK_EX) }
+          else
+            @file.flock(File::LOCK_EX)
+          end
+          @lock_acquired = true
+          true
+        end
+
+        #
+        def release_lock!
+          Mimi::DB.logger.info "! Unlocking file: #{lock_filename}"
+          @file.flock(File::LOCK_UN) if @lock_acquired
+          @file.close
+          # NOTE: do not unlink file here, it leads to a potential race condition:
+          # http://world.std.com/~swmcd/steven/tech/flock.html
+          true
+        end
+      end # class SqliteLock
+    end # module Lock
+  end # module DB
+end # module Mimi

data/lib/mimi/db/lock.rb

@@ -0,0 +1,73 @@
+#
+# NOTE: mimi/db/lock is NOT required automatically on require "mimi/db"
+#
+module Mimi
+  module DB
+    module Lock
+      include Mimi::Core::Module
+
+      default_options(
+        default_lock_options: {
+          # nil     -- wait indefinitely
+          # 0       -- do not wait
+          # <float> -- wait number of seconds
+          timeout: nil
+        }
+      )
+
+      def self.module_path
+        Pathname.new(__dir__).join('lock')
+      end
+
+      def self.configure(*)
+        super
+        Mimi::DB.extend(self)
+      end
+
+      def self.start
+        require_relative 'lock/postgresql_lock'
+        require_relative 'lock/mysql_lock'
+        require_relative 'lock/sqlite_lock'
+        super
+      end
+
+      # Obtains a named lock
+      #
+      # @param [String,Symbol] name
+      # @param [Hash] opts
+      # @option opts [Numeric,nil] :timeout Timeout in seconds
+      # @option opts [Boolean] :temporary Remove the lock
+      #
+      # @return [true] if the lock was obtained and the block executed
+      # @return [Falsey] if the lock was NOT obtained
+      #
+      def lock(name, opts = {}, &block)
+        lock!(name, opts, &block)
+        true
+      rescue NotAvailable
+        nil
+      end
+
+      def lock!(name, opts = {}, &block)
+        opts = Mimi::DB::Lock.module_options[:default_lock_options].merge(opts.dup)
+        adapter_name = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+        case adapter_name
+        when :postgresql, :empostgresql, :postgis
+          Mimi::DB::Lock::PostgresqlLock.new(name, opts).execute(&block)
+        when :mysql, :mysql2
+          Mimi::DB::Lock::MysqlLock.new(name, opts).execute(&block)
+        when :sqlite
+          Mimi::DB::Lock::SqliteLock.new(name, opts).execute(&block)
+        else
+          raise "Named locks not supported by the adapter: #{adapter_name}"
+        end
+      end
+
+      # Lock was not acquired error
+      #
+      class NotAvailable < RuntimeError
+      end # class Error
+      #
+    end # module Lock
+  end # module DB
+end # module Mimi

data/lib/mimi/db/version.rb

@@ -1,5 +1,5 @@
 module Mimi
   module DB
-    VERSION = '0.1.2'.freeze
+    VERSION = '0.1.3'.freeze
   end
 end

data/lib/mimi/db.rb

@@ -1,7 +1,6 @@
 require 'mimi/core'
 require 'active_record'
 require 'mini_record'
-require 'with_advisory_lock'
 
 module Mimi
   module DB
@@ -92,32 +91,10 @@ module Mimi
         reaping_frequency: 15
       }.stringify_keys
     end
-
-    def self.models
-      ActiveRecord::Base.descendants
-    end
-
-    def self.migrate_schema!
-      models.each(&:auto_upgrade!)
-    end
-
-    def self.create!
-      ActiveRecord::Tasks::DatabaseTasks.root = Mimi.app_root_path
-      ActiveRecord::Tasks::DatabaseTasks.create(active_record_config)
-    end
-
-    def self.drop!
-      ActiveRecord::Tasks::DatabaseTasks.root = Mimi.app_root_path
-      ActiveRecord::Tasks::DatabaseTasks.drop(active_record_config)
-    end
-
-    def self.clear!
-      ActiveRecord::Tasks::DatabaseTasks.root = Mimi.app_root_path
-      ActiveRecord::Tasks::DatabaseTasks.purge(active_record_config)
-    end
   end # module DB
 end # module Mimi
 
 require_relative 'db/version'
 require_relative 'db/extensions'
+require_relative 'db/helpers'
 require_relative 'db/foreign_key'

data/mimi-db.gemspec

@@ -30,7 +30,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'mimi-core', '~> 0.1'
   spec.add_dependency 'activerecord', '~> 4.2'
   spec.add_dependency 'mini_record', '~> 0.4'
-  spec.add_dependency 'with_advisory_lock', '~> 3.0'
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mimi-db
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Alex Kukushkin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-12 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mimi-core
@@ -52,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
-- !ruby/object:Gem::Dependency
-  name: with_advisory_lock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -142,6 +128,11 @@ files:
 - lib/mimi/db.rb
 - lib/mimi/db/extensions.rb
 - lib/mimi/db/foreign_key.rb
+- lib/mimi/db/helpers.rb
+- lib/mimi/db/lock.rb
+- lib/mimi/db/lock/mysql_lock.rb
+- lib/mimi/db/lock/postgresql_lock.rb
+- lib/mimi/db/lock/sqlite_lock.rb
 - lib/mimi/db/version.rb
 - lib/tasks/db.rake
 - mimi-db.gemspec