mongo_mutex 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a899ddda53434cc9bcb3160e4cd2d4ab0cf6a8d
+  data.tar.gz: 60fc670259bba255522221e4ee73db1b498773ae
+SHA512:
+  metadata.gz: af3c6349d873aa41ff186190f14d5e8c7f688171daa4a97614e62fb438772980b1bc578bc0335d1920b5741761fe4d264d8f239d0bb5faf90e72d8c27b8a56c8
+  data.tar.gz: 59f6faa7f7d3a9b2ec12e35104c55bcb793e2a56f0bb561ad9ff907f7417d18f46a0036b092f588082f470afb806dfd82b9b31e801dc03aa2a8962eae11fde57

data/bin/mongo_mutex

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'mongo_mutex'
+require 'socket'
+require 'optionparser'
+require 'open3'
+Mongo::Logger.logger.level = ::Logger::FATAL
+
+hosts = ['127.0.0.1']
+database_name = 'mongo_mutex'
+collection_name = 'mutex'
+lock_name = nil
+locker_name = Socket.gethostname
+block_on_complete = nil
+options = {
+  # logger: Logger.new(STDOUT)
+}
+
+OptionParser.new do |opts|
+  opts.on('-c CONFIG_FILE', 'Path to config file containing mongodb connection uri') do |filename|
+    hosts = File.readlines(filename).map(&:strip).reject(&:empty?)
+  end
+
+  opts.on('-h host1,host2', Array, 'MongoDB hosts (defaults to localhost)') do |h|
+    hosts = h.map(&:strip)
+  end
+
+  opts.on('-d DATABASE', '--database DATABASE', 'Database to use (default mongo_mutex)') do |db|
+    database_name = db
+  end
+
+  opts.on('-l LOCK_NAME', '--lock LOCK_NAME', 'Name of the distributed lock') do |lock|
+    lock_name = lock
+  end
+
+  opts.on('-n LOCKER_NAME', '--locker LOCKER_NAME', 'Name of the locking node (defaults to hostname)') do |name|
+    locker_name = name
+  end
+
+  opts.on('--retention N', Integer, 'Lock retention period in seconds (default 600)') do |retention|
+    options[:lock_retention_timeout] = retention
+  end
+
+  opts.on('--block N', Integer, 'On success, block other nodes from executing for N seconds') do |block_time|
+    block_on_complete = block_time
+  end
+end.parse!
+
+raise OptionParser::MissingArgument.new('Lock name is mandatory') unless lock_name
+
+module Enumerable
+  alias :all_are? :all?
+end
+
+command = ARGV.join(' ')
+
+collection = Mongo::Client.new(hosts, :database => database_name)[collection_name]
+mutex = MongoMutex::Mutex.new(collection, lock_name, locker_name, options)
+complete_mutex = MongoMutex::Mutex.new(collection, "#{lock_name}_complete", locker_name, options.merge(:lock_retention_timeout => block_on_complete)) if block_on_complete
+
+mutex.synchronize do
+  if complete_mutex && complete_mutex.locked?
+    puts "Job already completed, skipping"
+    exit
+  end
+  Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+    maxlen = 1024
+    pipes = {
+      stdout => $stdout,
+      stderr => $stderr
+    }
+    until pipes.empty?
+      IO.select(pipes.keys).first.each do |io|
+        begin
+          pipes[io].write io.read_nonblock(maxlen)
+        rescue EOFError
+          pipes.delete(io)
+        end
+      end
+    end
+    complete_mutex && complete_mutex.try_lock
+  end
+end

data/lib/mongo_mutex/mutex.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+require 'mongo'
+
+module MongoMutex
+  class Mutex
+    def initialize(collection, lock_id, locker_id, options = {})
+      raise ArgumentError, "String lock id required" unless lock_id.is_a?(String)
+      raise ArgumentError, "String locker id required" unless locker_id.is_a?(String)
+      @collection = collection
+      @lock_id = lock_id
+      @locker_id = locker_id
+      options = options.dup
+      @lock_check_period = options.delete(:lock_check_period) || 5
+      @lock_retention_timeout = options.delete(:lock_retention_timeout) || 600
+      @clock = options.delete(:clock) || Time
+      @logger = options.delete(:logger)
+      @lock_operations = options.delete(:lock_operations) || MongoOperations.new
+      raise ArgumentError, "Unsupported options #{options.keys}" unless options.empty?
+    end
+
+    def try_lock
+      previous = @lock_operations.try_lock(@collection, @lock_id, @locker_id, @clock.now, @lock_retention_timeout)
+      if previous && (locked_by = previous[LOCKED_BY])
+        if expired?(previous[LOCKED_AT])
+          @logger.warn "Ignoring old #{@lock_id} lock by #{locked_by} since #{previous[LOCKED_AT]} was too long ago" if @logger
+        else
+          raise ThreadError, "mutex already locked by #{locked_by} at #{previous[LOCKED_AT]}"
+        end
+      end
+      true
+    rescue Mongo::Error::OperationFailure => error
+      if error.message.include?(DUPLICATE_KEY_ERROR)
+        return false
+      else
+        raise
+      end
+    end
+
+    def locked?
+      lock_info = @lock_operations.lock_info(@collection, @lock_id)
+      lock_info && lock_info[LOCKED_BY] && !expired?(lock_info[LOCKED_AT])
+    end
+
+    def lock
+      until try_lock
+        sleep @lock_check_period
+      end
+      self
+    end
+
+    def unlock
+      unless @lock_operations.unlock(@collection, @lock_id, @locker_id, @clock.now, @lock_retention_timeout)
+        raise ThreadError, 'lock is either not locked or locked by someone else'
+      end
+      self
+    end
+
+    def synchronize(&block)
+      lock
+      begin
+        yield
+      ensure
+        unlock
+      end
+    end
+
+    private
+
+    LOCKED_BY = 'locked_by'.freeze
+    LOCKED_AT = 'locked_at'.freeze
+
+    def expired?(time)
+      !time || time < @clock.now - @lock_retention_timeout
+    end
+
+    DUPLICATE_KEY_ERROR = 'E11000'
+
+    class MongoOperations
+      def lock_info(collection, lock_id)
+        collection.find({_id: lock_id}, limit: 1).first
+      end
+
+      def try_lock(collection, lock_id, locker_id, now, lock_retention_timeout)
+        collection.find_one_and_update(
+          {:_id => lock_id, :$or => [
+            {locked_at: {:$lt => now - lock_retention_timeout}},
+            {locked_by: locker_id},
+            {locked_by: {:$exists => 0}},
+          ]},
+          {_id: lock_id, locked_by: locker_id, locked_at: now},
+          upsert: true,
+        )
+      end
+
+      def unlock(collection, lock_id, locker_id, now, lock_retention_support)
+        collection.find_one_and_update(
+          {_id: lock_id, locked_by: locker_id, locked_at: {:$gte => now - lock_retention_support}},
+          {:$unset => {locked_by: 1, locked_at: 1}},
+        )
+      end
+    end
+  end
+end

data/lib/mongo_mutex.rb

@@ -0,0 +1 @@
+require 'mongo_mutex/mutex'

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: mongo_mutex
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Dahl
+- Gustav Munkby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: A distributed lock using MongoDB as backend
+email: david@burtcorp.com
+executables:
+- mongo_mutex
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/mongo_mutex
+- lib/mongo_mutex.rb
+- lib/mongo_mutex/mutex.rb
+homepage: https://github.com/effata/mongo_mutex
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Mongo Mutex
+test_files: []