redis-em-mutex 0.1.0

data/README.rdoc

@@ -0,0 +1,179 @@
+= redis-em-mutex
+
+Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
+
+* http://github.com/royaltm/redis-em-mutex
+
+== DESCRIPTION
+
+*redis-em-mutex* is the cross server-process-fiber EventMachine + Redis based semaphore.
+
+== FEATURES
+
+* only for EventMachine
+* no CPU-intensive sleep/polling while waiting for lock to become available
+* fibers waiting for the lock are signalled via Redis channel as soon as the lock
+  has been released (~< 1 ms)
+* multi-locks (all-or-nothing) locking (to prevent possible deadlocks when
+  multiple semaphores are required to be locked at once)
+* best served with EM-Synchrony (uses EM::Synchrony::ConnectionPool internally)
+* fiber-safe
+* deadlock detection (only trivial cases: locking twice the same resource from the same fiber)
+* mandatory lock expiration (with refreshing)
+
+== BUGS/LIMITATIONS
+
+* only for EventMachine
+* NOT thread-safe
+* locking order between concurrent processes is undetermined (no FIFO)
+* its not nifty, rather somewhat complicated
+
+== REQUIREMENTS
+
+* ruby >= 1.9 (tested: 1.9.3-p194, 1.9.2-p320, 1.9.1-p378)
+* http://github.com/redis/redis-rb >= 3.0.1
+* http://rubyeventmachine.com >= 0.12.10
+* (optional) http://github.com/igrigorik/em-synchrony
+
+== INSTALL
+
+  $ [sudo] gem install redis-em-mutex
+
+==== Gemfile
+
+  gem "redis-em-mutex", "~> 0.1.0"
+
+==== Github
+
+  git clone git://github.com/royaltm/redis-em-mutex.git
+
+== USAGE
+
+  require 'em-synchrony'
+  require 'em-redis-mutex'
+
+  Redis::EM::Mutex.setup(size: 10, url: 'redis:///1', expire: 600)
+
+  # or
+
+  Redis::EM::Mutex.setup do |opts|
+    opts.size = 10
+    opts.url = 'redis:///1'
+    ...
+  end
+
+
+  EM.synchrony do
+    Redis::EM::Mutex.synchronize('resource.lock') do
+      ... do something with resource
+    end
+
+    # or 
+
+    mutex = Redis::EM::Mutex.new('resource.lock')
+    mutex.synchronize do
+      ... do something with resource
+    end
+
+    # or
+
+    begin
+      mutex.lock
+      ... do something with resource
+    ensure
+      mutex.unlock
+    end
+
+    ...
+
+    Redis::EM::Mutex.stop_watcher
+    EM.stop
+  end
+
+=== Namespaces
+
+  Redis::EM::Mutex.setup(ns: 'my_namespace', ....)
+
+  # or multiple namespaces:
+
+  ns = Redis::EM::Mutex::NS.new('my_namespace')
+
+  EM.synchrony do
+    ns.synchronize('foo') do
+      .... do something with foo and bar
+    end
+    ...
+    EM.stop
+  end
+
+=== Multi-locks
+
+  EM.synchrony do
+    Redis::EM::Mutex.synchronize('foo', 'bar', 'baz') do
+      .... do something with foo, bar and baz
+    end
+    ...
+    EM.stop
+  end
+
+=== Locking options
+
+  EM.synchrony do
+    begin
+      Redis::EM::Mutex.synchronize('foo', 'bar', block: 0.25) do
+        .... do something with foo and bar
+      end
+    rescue Redis::EM::Mutex::MutexTimeout
+      ... locking timed out
+    end
+
+    Redis::EM::Mutex.synchronize('foo', 'bar', expire: 60) do |mutex|
+      .... do something with foo and bar in less than 60 seconds
+      if mutex.refresh(120)
+        # now we have additional 120 seconds until lock expires
+      else
+        # too late
+      end
+    end
+
+    ...
+    EM.stop
+  end
+
+=== Advanced
+
+  mutex = Redis::EM::Mutex.new('resource1', 'resource2', expire: 60)
+
+  EM.synchrony do
+    mutex.lock
+
+    EM.fork_reactor do
+      Fiber.new do
+        mutex.locked? # true
+        mutex.owned?  # false
+        mutex.synchronize do
+          mutex.locked? # true
+          mutex.owned?  # true
+
+          ....
+        end
+        ...
+        Redis::EM::Mutex.stop_watcher
+        EM.stop
+      end.resume
+    end
+
+    mutex.locked? # true
+    mutex.owned?  # true
+
+    mutex.unlock
+    mutex.owned?  # false
+
+    ...
+    Redis::EM::Mutex.stop_watcher
+    EM.stop
+  end
+
+== LICENCE
+
+The MIT License - Copyright (c) 2012 Rafał Michalski

data/Rakefile

@@ -0,0 +1,35 @@
+$:.unshift "lib"
+
+task :default => [:test]
+
+$gem_name = "redis-em-mutex"
+
+desc "Run spec tests"
+task :test do
+  sh "rspec spec/*.rb"
+end
+
+desc "Build the gem"
+task :gem do
+  sh "gem build #$gem_name.gemspec"
+end
+
+desc "Install the library at local machnie"
+task :install => :gem do 
+  sh "gem install #$gem_name -l"
+end
+
+desc "Uninstall the library from local machnie"
+task :uninstall do
+  sh "gem uninstall #$gem_name"
+end
+
+desc "Clean"
+task :clean do
+  sh "rm #$gem_name*.gem"
+end
+
+desc "Documentation"
+task :doc do
+  sh "rdoc --encoding=UTF-8 --title=#$gem_name --main=README.rdoc README.rdoc lib/*.rb lib/*/*.rb"
+end

data/lib/redis-em-mutex.rb

@@ -0,0 +1,5 @@
+class Redis
+  module EM
+    autoload :Mutex, 'redis/em-mutex'
+  end
+end

data/lib/redis/em-mutex.rb

@@ -0,0 +1,555 @@
+# -*- coding: UTF-8 -*-
+# require 'digest'
+# require 'base64'
+require 'ostruct'
+require 'securerandom'
+require 'redis/connection/synchrony' unless defined? Redis::Connection::Synchrony
+require 'redis'
+
+class Redis
+  module EM
+    # Cross Machine-Process-Fiber EventMachine/Redis based semaphore.
+    #
+    # WARNING:
+    #
+    # Methods of this class are NOT thread-safe.
+    # They are machine/process/fiber-safe.
+    # All method calls must be invoked only from EventMachine's reactor thread.
+    #
+    # - The terms "lock" and "semaphore" used in documentation are synonims.
+    # - The term "owner" denotes a Ruby Fiber in some Process on some Machine.
+    #
+    class Mutex
+      VERSION = '0.1.0'
+      module Errors
+        class MutexError < RuntimeError; end
+        class MutexTimeout < MutexError; end
+      end
+
+      include Errors
+      extend Errors
+
+      @@connection_pool_class = nil
+      @@connection_retry_max = 10
+      @@default_expire = 3600*24
+      AUTO_NAME_SEED = '__@'
+      SIGNAL_QUEUE_CHANNEL = "::#{self.name}::"
+      @@name_index = AUTO_NAME_SEED
+      @@redis_pool = nil
+      @@redis_watcher = nil
+      @@watching = false
+      @@watcher_subscribed = false
+      @@signal_queue = Hash.new {|h,k| h[k] = []}
+      @@ns = nil
+      @@uuid = nil
+
+      attr_accessor :expire_timeout, :block_timeout
+      attr_reader :names, :ns
+      alias_method :namespace, :ns
+
+      class NS
+        attr_reader :ns
+        alias_method :namespace, :ns
+        # Creates a new namespace (Mutex factory).
+        #
+        # - ns = namespace
+        # - opts = options hash:
+        # - :block - default block timeout
+        # - :expire - default expire timeout
+        def initialize(ns, opts = {})
+          @ns = ns
+          @opts = (opts || {}).merge(:ns => ns)
+        end
+
+        # Creates a namespaced cross machine/process/fiber semaphore.
+        #
+        # for arguments see: Redis::EM::Mutex.new
+        def new(*args)
+          if args.last.kind_of?(Hash)
+            args[-1] = @opts.merge(args.last)
+          else
+            args.push @opts
+          end
+          Redis::EM::Mutex.new(*args)
+        end
+
+        # Attempts to grab the lock and waits if it isn’t available.
+        # 
+        # See: Redis::EM::Mutex.lock
+        def lock(*args)
+          mutex = new(*args)
+          mutex if mutex.lock
+        end
+
+        # Executes block of code protected with namespaced semaphore.
+        #
+        # See: Redis::EM::Mutex.synchronize
+        def synchronize(*args, &block)
+          new(*args).synchronize(&block)
+        end
+      end
+
+      # Creates a new cross machine/process/fiber semaphore
+      #
+      #   Redis::EM::Mutex.new(*names, opts = {})
+      #
+      # - *names = lock identifiers - if none they are auto generated
+      # - opts = options hash:
+      # - :name - same as *names (in case *names arguments were omitted)
+      # - :block - default block timeout
+      # - :expire - default expire timeout (see: Mutex#lock and Mutex#try_lock)
+      # - :ns - local namespace (otherwise global namespace is used)
+      def initialize(*args)
+        raise MutexError, "call #{self.class}::setup first" unless @@redis_pool
+
+        opts = args.last.kind_of?(Hash) ? args.pop : {}
+
+        @names = args
+        @names = Array(opts[:name] || "#{@@name_index.succ!}.lock") if @names.empty?
+        raise MutexError, "semaphore names must not be empty" if @names.empty?
+        @multi = !@names.one?
+        @ns = opts[:ns] || @@ns
+        @ns_names = @ns ? @names.map {|n| "#@ns:#@n" } : @names
+        @expire_timeout = opts[:expire]
+        @block_timeout = opts[:block]
+        @locked_id = nil
+      end
+
+      # Returns `true` if this semaphore (at least one of locked `names`) is currently being held by some owner.
+      def locked?
+        if @multi
+          @@redis_pool.multi do |multi|
+            @ns_names.each {|n| multi.exists n}
+          end.any?
+        else
+          @@redis_pool.exists @ns_names.first
+        end
+      end
+
+      # Returns `true` if this semaphore (all the locked `names`) is currently being held by calling fiber.
+      def owned?
+        !!if @locked_id
+          lock_full_ident = owner_ident(@locked_id)
+          @@redis_pool.mget(*@ns_names).all? {|v| v == lock_full_ident}
+        end
+      end
+
+      # Attempts to obtain the lock and returns immediately.
+      # Returns `true` if the lock was granted.
+      # Use Mutex#expire_timeout= to set custom lock expiration time in secods.
+      # Otherwise global Mutex.default_expire is used.
+      #
+      # This method does not lock expired semaphores.
+      # Use Mutex#lock with block_timeout = 0 to obtain expired lock without blocking.
+      def try_lock
+        lock_id = (Time.now + (@expire_timeout.to_f.nonzero? || @@default_expire)).to_f.to_s
+        !!if @multi
+          lock_full_ident = owner_ident(lock_id)
+          if @@redis_pool.msetnx(*@ns_names.map {|k| [k, lock_full_ident]}.flatten)
+            @locked_id = lock_id
+          end
+        elsif @@redis_pool.setnx(@ns_names.first, owner_ident(lock_id))
+          @locked_id = lock_id
+        end
+      end
+
+      # Refreshes lock expiration timeout.
+      # Returns true if refresh was successfull or false if mutex was not locked or has already expired.
+      def refresh(expire_timeout=nil)
+        ret = false
+        if @locked_id
+          new_lock_id = (Time.now + (expire_timeout.to_f.nonzero? || @expire_timeout.to_f.nonzero? || @@default_expire)).to_f.to_s
+          new_lock_full_ident = owner_ident(new_lock_id)
+          lock_full_ident = owner_ident(@locked_id)
+          @@redis_pool.execute(false) do |r|
+            r.watch(*@ns_names) do
+              if r.mget(*@ns_names).all? {|v| v == lock_full_ident}
+                ret = !!r.multi do |multi|
+                  multi.mset(*@ns_names.map {|k| [k, new_lock_full_ident]}.flatten)
+                end
+                @locked_id = new_lock_id if ret
+              else
+                r.unwatch
+              end
+            end
+          end
+        end
+        ret
+      end
+
+      # Releases the lock unconditionally.
+      # If semaphore wasn’t locked by the current owner it is silently ignored.
+      # Returns self.
+      def unlock
+        if @locked_id
+          lock_full_ident = owner_ident(@locked_id)
+          @@redis_pool.execute(false) do |r|
+            r.watch(*@ns_names) do
+              if r.mget(*@ns_names).all? {|v| v == lock_full_ident}
+                r.multi do |multi|
+                  multi.del(*@ns_names)
+                  multi.publish SIGNAL_QUEUE_CHANNEL, Marshal.dump(@ns_names)
+                end
+              else
+                r.unwatch
+              end
+            end
+          end
+        end
+        self
+      end
+
+      # Attempts to grab the lock and waits if it isn’t available.
+      # Raises MutexError if mutex was locked by the current owner.
+      # Returns `true` if lock was successfully obtained.
+      # Returns `false` if lock wasn't available within `block_timeout` seconds.
+      #
+      # If `block_timeout` is `nil` or omited this method uses Mutex#block_timeout.
+      # If also Mutex#block_timeout is nil this method returns only after lock
+      # has been granted.
+      #
+      # Use Mutex#expire_timeout= to set lock expiration timeout.
+      # Otherwise global Mutex.default_expire is used.
+      def lock(block_timeout = nil)
+        block_timeout||= @block_timeout
+        names = @ns_names
+        timer = fiber = nil
+        try_again = false
+        handler = proc do
+          try_again = true
+          ::EM.next_tick { fiber.resume if fiber } if fiber
+        end
+        queues = names.map {|n| @@signal_queue[n] << handler }
+        ident_match = owner_ident
+        until try_lock
+          Mutex.start_watcher unless @@watching == $$
+          start_time = Time.now.to_f
+          expire_time = nil
+          @@redis_pool.execute(false) do |r|
+            r.watch(*names) do
+              expired_names = names.zip(r.mget(*names)).map do |name, lock_value|
+                if lock_value
+                  owner, exp_id = lock_value.split ' '
+                  exp_time = exp_id.to_f
+                  expire_time = exp_time if expire_time.nil? || exp_time < expire_time
+                  raise MutexError, "deadlock; recursive locking #{owner}" if owner == ident_match
+                  if exp_time < start_time
+                    name
+                  end
+                end
+              end
+              if expire_time && expire_time < start_time
+                r.multi do |multi|
+                  expired_names = expired_names.compact
+                  multi.del(*expired_names)
+                  multi.publish SIGNAL_QUEUE_CHANNEL, Marshal.dump(expired_names)
+                end
+              else
+                r.unwatch
+              end
+            end
+          end
+          timeout = expire_time.to_f - start_time
+          timeout = block_timeout if block_timeout && block_timeout < timeout
+
+          if !try_again && timeout > 0
+            timer = ::EM::Timer.new(timeout) do
+              timer = nil
+              ::EM.next_tick { fiber.resume if fiber } if fiber
+            end
+            fiber = Fiber.current
+            Fiber.yield 
+            fiber = nil
+          end
+          finish_time = Time.now.to_f
+          if try_again || finish_time > expire_time
+            block_timeout-= finish_time - start_time if block_timeout
+            try_again = false
+          else
+            return false
+          end
+        end
+        true
+      ensure
+        timer.cancel if timer
+        timer = nil
+        queues.each {|q| q.delete handler }
+        names.each {|n| @@signal_queue.delete(n) if @@signal_queue[n].empty? }
+        @@signal_queue.inspect
+      end
+
+      # Execute block of code protected with semaphore.
+      # Returns result of code block.
+      #
+      # If `block_timeout` or Mutex#block_timeout is set and
+      # lock isn't obtained within `block_timeout` seconds this method raises
+      # MutexTimeout.
+      def synchronize(block_timeout = nil)
+        if lock(block_timeout)
+          begin
+            yield self
+          ensure
+            unlock
+          end
+        else
+          raise MutexTimeout
+        end
+      end
+
+      class << self
+        def ns; @@ns; end
+        def ns=(namespace); @@ns = namespace; end
+        alias_method :namespace, :ns
+        alias_method :'namespace=', :'ns='
+        
+        # Default value of expiration timeout in seconds.
+        def default_expire; @@default_expire; end
+        
+        # Assigns default value of expiration timeout in seconds.
+        # Must be > 0.
+        def default_expire=(value); @@default_expire=value.to_f.abs; end
+
+        # Setup redis database and other defaults
+        # MUST BE called once before any semaphore is created.
+        #
+        # opts = options Hash:
+        #
+        # global options:
+        #
+        # - :connection_pool_class - default is ::EM::Synchrony::ConnectionPool
+        # - :expire   - sets global Mutex.default_expire 
+        # - :ns       - sets global Mutex.namespace
+        # - :reconnect_max - maximum num. of attempts to re-establish
+        #   connection to redis server;
+        #   default is 10; set to 0 to disable re-connecting;
+        #   set to -1 to attempt forever
+        #
+        # redis connection options:
+        #
+        # - :size     - redis connection pool size
+        #
+        # passed directly to Redis.new:
+        #
+        # - :url      - redis server url
+        #
+        # or
+        #
+        # - :scheme   - "redis" or "unix"
+        # - :host     - redis host
+        # - :port     - redis port
+        # - :password - redis password
+        # - :db       - redis database number
+        # - :path     - redis unix-socket path
+        #
+        # or
+        #
+        # - :redis    - initialized ConnectionPool of Redis clients.
+        def setup(opts = {})
+          stop_watcher
+          opts = OpenStruct.new(opts)
+          yield opts if block_given?
+          @@connection_pool_class = opts.connection_pool_class if opts.connection_pool_class.kind_of?(Class)
+          @redis_options = redis_options = {:driver => :synchrony}
+          redis_updater = proc do |redis|
+            redis_options.update({
+              :scheme => redis.scheme,
+              :host   => redis.host,
+              :port   => redis.port,
+              :password => redis.password,
+              :db       => redis.db,
+              :path     => redis.path
+            }.reject {|_k, v| v.nil?})
+          end
+          if (redis = opts.redis) && !opts.url
+            redis_updater.call redis
+          elsif opts.url
+            redis_options[:url] = opts.url
+          end
+          redis_updater.call opts
+          namespace = opts.ns
+          pool_size = (opts.size.to_i.nonzero? || 1).abs
+          self.default_expire = opts.expire if opts.expire
+          @@connection_retry_max = opts.reconnect_max.to_i if opts.reconnect_max
+          @@ns = namespace if namespace
+          # generate machine uuid
+          # todo: should probably use NIC ethernet address or uuid gem
+          # dhash = ::Digest::SHA1.new
+          # rnd = Random.new
+          # 256.times { dhash.update [rnd.rand(0x100000000)].pack "N" }
+          # digest = dhash.digest
+          # dsize, doffs = digest.bytesize.divmod 6
+          # @@uuid = Base64.encode64(digest[rnd.rand(doffs + 1), dsize * 6]).chomp
+          @@uuid = SecureRandom.uuid
+
+          unless (@@redis_pool = redis)
+            unless @@connection_pool_class
+              begin
+                require 'em-synchrony/connection_pool' unless defined?(::EM::Synchrony::ConnectionPool)
+              rescue LoadError
+                raise ":connection_pool_class required; could not fall back to EM::Synchrony::ConnectionPool - gem install em-synchrony"
+              end
+              @@connection_pool_class = ::EM::Synchrony::ConnectionPool
+            end
+            @@redis_pool = @@connection_pool_class.new(size: pool_size) do
+              Redis.new redis_options
+            end
+          end
+          @@redis_watcher = Redis.new redis_options
+          start_watcher if ::EM.reactor_running?
+        end
+
+        # resets Mutex's automatic name generator
+        def reset_autoname
+          @@name_index = AUTO_NAME_SEED
+        end
+
+        def wakeup_queue_all
+          @@signal_queue.each_value do |queue|
+            queue.each {|h| h.call }
+          end
+        end
+
+        # Initializes the "unlock" channel watcher. Its called by Mutex.setup
+        # internally. Should not be used under normal circumstances.
+        # If EventMachine is to be re-started (or after EM.fork_reactor) this method may be used instead of
+        # Mutex.setup for "lightweight" startup procedure.
+        def start_watcher
+          raise MutexError, "call #{self.class}::setup first" unless @@redis_watcher
+          return if @@watching == $$
+          if @@watching
+            @@redis_watcher = Redis.new @redis_options
+            @@signal_queue.clear
+          end
+          @@watching = $$
+          retries = 0
+          Fiber.new do
+            begin
+              @@redis_watcher.subscribe(SIGNAL_QUEUE_CHANNEL) do |on|
+                on.subscribe do |channel,|
+                  if channel == SIGNAL_QUEUE_CHANNEL
+                    @@watcher_subscribed = true
+                    retries = 0
+                    wakeup_queue_all
+                  end
+                end
+                on.message do |channel, message|
+                  if channel == SIGNAL_QUEUE_CHANNEL
+                    handlers = {}
+                    Marshal.load(message).each do |name|
+                      handlers[@@signal_queue[name].first] = true if @@signal_queue.key?(name)
+                    end
+                    handlers.keys.each do |handler|
+                      handler.call if handler
+                    end
+                  end
+                end
+                on.unsubscribe do |channel,|
+                  @@watcher_subscribed = false if channel == SIGNAL_QUEUE_CHANNEL
+                end
+              end
+              break
+            rescue Redis::BaseConnectionError, EventMachine::ConnectionError => e
+              @@watcher_subscribed = false
+              warn e.message
+              retries+= 1
+              if retries > @@connection_retry_max && @@connection_retry_max >= 0
+                @@watching = false
+              else
+                sleep retries > 1 ? 1 : 0.1
+              end
+            end while @@watching == $$
+          end.resume
+          until @@watcher_subscribed
+            raise MutexError, "Can not establish watcher channel connection!" unless @@watching == $$
+            fiber = Fiber.current
+            ::EM.next_tick { fiber.resume }
+            Fiber.yield
+          end
+        end
+
+        def sleep(seconds)
+          fiber = Fiber.current
+          ::EM::Timer.new(secs) { fiber.resume }
+          Fiber.yield
+        end
+
+        # Stops the watcher of the "unlock" channel.
+        # It should be called before stoping EvenMachine otherwise
+        # EM might wait forever for channel connection to be closed.
+        #
+        # Raises MutexError if there are still some fibers waiting for a lock.
+        # Pass `true` to forcefully stop it. This might instead cause
+        # MutexError to be raised in waiting fibers.
+        def stop_watcher(force = false)
+          return unless @@watching == $$
+          @@watching = false
+          raise MutexError, "call #{self.class}::setup first" unless @@redis_watcher
+          unless @@signal_queue.empty? || force
+            raise MutexError, "can't stop: active signal queue handlers"
+          end
+          if @@watcher_subscribed
+            @@redis_watcher.unsubscribe SIGNAL_QUEUE_CHANNEL
+            while @@watcher_subscribed
+              fiber = Fiber.current
+              ::EM.next_tick { fiber.resume }
+              Fiber.yield
+            end
+          end
+        end
+
+        # Remove all current Machine/Process locks.
+        # Since there is no lock tracking mechanism, it might not be implemented easily.
+        # If the need arises then it probably should be implemented.
+        def sweep
+          raise NotImplementedError
+        end
+
+        # Attempts to grab the lock and waits if it isn’t available.
+        # Raises MutexError if mutex was locked by the current owner.
+        # Returns instance of Redis::EM::Mutex if lock was successfully obtained.
+        # Returns `nil` if lock wasn't available within `:block` seconds.
+        #
+        #   Redis::EM::Mutex.lock(*names, opts = {})
+        #
+        # - *names = lock identifiers - if none they are auto generated
+        # - opts = options hash:
+        # - :name - same as name (in case *names arguments were omitted)
+        # - :block - block timeout
+        # - :expire - expire timeout (see: Mutex#lock and Mutex#try_lock)
+        # - :ns - namespace (otherwise global namespace is used)
+        def lock(*args)
+          mutex = new(*args)
+          mutex if mutex.lock
+        end
+        # Execute block of code protected with named semaphore.
+        # Returns result of code block.
+        #
+        #   Redis::EM::Mutex.synchronize(*names, opts = {}, &block)
+        # 
+        # - *names = lock identifiers - if none they are auto generated
+        # - opts = options hash:
+        # - :name - same as name (in case *names arguments were omitted)
+        # - :block - block timeout
+        # - :expire - expire timeout (see: Mutex#lock and Mutex#try_lock)
+        # - :ns - namespace (otherwise global namespace is used)
+        # 
+        # If `:block` is set and lock isn't obtained within `:block` seconds this method raises
+        # MutexTimeout.
+        def synchronize(*args, &block)
+          new(*args).synchronize(&block)
+        end
+      end
+
+      private
+
+      def owner_ident(lock_id = nil)
+        if lock_id
+          "#@@uuid$#$$@#{Fiber.current.__id__} #{lock_id}"
+        else
+          "#@@uuid$#$$@#{Fiber.current.__id__}"
+        end
+      end
+
+    end
+  end
+end

data/redis-em-mutex.gemspec

@@ -0,0 +1,28 @@
+$:.unshift "lib"
+require 'redis/em-mutex'
+
+Gem::Specification.new do |s|
+  s.name = "redis-em-mutex"
+  s.version = Redis::EM::Mutex::VERSION
+  s.required_ruby_version = ">= 1.9.1"
+  s.date = "#{Time.now.strftime("%Y-%m-%d")}"
+  s.summary = "Cross server-process-fiber EventMachine + Redis based semaphore"
+  s.email = "rafal@yeondir.com"
+  s.homepage = "http://github.com/royaltm/redis-em-mutex"
+  s.require_path = "lib"
+  s.description = "Cross server-process-fiber EventMachine + Redis based semaphore with many features"
+  s.authors = ["Rafal Michalski"]
+  s.files = `git ls-files`.split("\n") - ['.gitignore']
+  s.test_files = Dir.glob("spec/**/*")
+  s.rdoc_options << "--title" << "redis-em-mutex" <<
+    "--main" << "README.rdoc"
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.requirements << "Redis server"
+  s.add_runtime_dependency "redis", ">= 3.0.0"
+  s.add_runtime_dependency "hiredis", "~> 0.4.5"
+  s.add_runtime_dependency "eventmachine", ">= 0.12.10"
+  s.add_development_dependency "rspec", "~> 2.8.0"
+  s.add_development_dependency "eventmachine", ">= 1.0.0.beta.1"
+  s.add_development_dependency "em-synchrony", "~> 1.0.0"
+end

data/spec/redis-em-mutex-features.rb

@@ -0,0 +1,33 @@
+$:.unshift "lib"
+require 'em-synchrony'
+require 'redis-em-mutex'
+
+describe Redis::EM::Mutex do
+
+  it "should raise MutexError while redis server not found on setup" do
+    expect {
+      described_class.setup(host: 'abcdefghijklmnopqrstuvwxyz', reconnect_max: 0)
+    }.to raise_error(described_class::MutexError, /Can not establish watcher channel connection!/)
+
+    expect {
+      described_class.setup(host: '255.255.255.255', reconnect_max: 0)
+    }.to raise_error(described_class::MutexError, /Can not establish watcher channel connection!/)
+
+    expect {
+      described_class.setup(port: 65535, reconnect_max: 0)
+    }.to raise_error(described_class::MutexError, /Can not establish watcher channel connection!/)
+  end
+
+  around(:each) do |testcase|
+    @after_em_stop = nil
+    ::EM.synchrony do
+      begin
+        testcase.call
+      ensure
+        ::EM.stop
+      end
+    end
+    @after_em_stop.call if @after_em_stop
+  end
+
+end

data/spec/redis-em-mutex-semaphores.rb

@@ -0,0 +1,337 @@
+$:.unshift "lib"
+require 'securerandom'
+require 'em-synchrony'
+require 'em-synchrony/fiber_iterator'
+require 'redis-em-mutex'
+
+describe Redis::EM::Mutex do
+
+  it "should lock and prevent locking on the same semaphore" do
+    begin
+      described_class.new(@lock_names.first).owned?.should be_false
+      mutex = described_class.lock(@lock_names.first)
+      mutex.names.should eq [@lock_names.first]
+      mutex.locked?.should be_true
+      mutex.owned?.should be_true
+      mutex.should be_an_instance_of described_class
+      described_class.new(@lock_names.first).try_lock.should be_false
+      expect {
+        mutex.lock
+      }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+      mutex.unlock.should be_an_instance_of described_class
+      mutex.locked?.should be_false
+      mutex.owned?.should be_false
+      mutex.try_lock.should be_true
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should lock and prevent locking on the same multiple semaphores" do
+    begin
+      mutex = described_class.lock(*@lock_names)
+      mutex.names.should eq @lock_names
+      mutex.locked?.should be_true
+      mutex.owned?.should be_true
+      mutex.should be_an_instance_of described_class
+      described_class.new(*@lock_names).try_lock.should be_false
+      @lock_names.each do |name|
+        described_class.new(name).try_lock.should be_false
+      end
+      mutex.try_lock.should be_false
+      expect {
+        mutex.lock
+      }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+      @lock_names.each do |name|
+        expect {
+          described_class.new(name).lock
+        }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+      end
+      mutex.unlock.should be_an_instance_of described_class
+      mutex.locked?.should be_false
+      mutex.owned?.should be_false
+      mutex.try_lock.should be_true
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should lock and prevent other fibers to lock on the same semaphore" do
+    begin
+      mutex = described_class.lock(@lock_names.first)
+      mutex.should be_an_instance_of described_class
+      mutex.owned?.should be_true
+      locked = true
+      ::EM::Synchrony.next_tick do
+        mutex.try_lock.should be false
+        mutex.owned?.should be_false
+        start = Time.now
+        mutex.synchronize do
+          (Time.now - start).should be_within(0.01).of(0.26)
+          locked.should be false
+          locked = nil
+        end
+      end
+      ::EM::Synchrony.sleep 0.25
+      locked = false
+      mutex.owned?.should be_true
+      mutex.unlock.should be_an_instance_of described_class
+      mutex.owned?.should be_false
+      ::EM::Synchrony.sleep 0.1
+      locked.should be_nil
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should lock and prevent other fibers to lock on the same multiple semaphores" do
+    begin
+      mutex = described_class.lock(*@lock_names)
+      mutex.should be_an_instance_of described_class
+      mutex.owned?.should be_true
+      locked = true
+      ::EM::Synchrony.next_tick do
+        locked.should be true
+        mutex.try_lock.should be false
+        mutex.owned?.should be_false
+        start = Time.now
+        mutex.synchronize do
+          mutex.owned?.should be_true
+          (Time.now - start).should be_within(0.01).of(0.26)
+          locked.should be false
+        end
+        mutex.owned?.should be_false
+        ::EM::Synchrony.sleep 0.1
+        start = Time.now
+        ::EM::Synchrony::FiberIterator.new(@lock_names, @lock_names.length).each do |name|
+          locked.should be true
+          described_class.new(name).synchronize do
+            (Time.now - start).should be_within(0.01).of(0.26)
+            locked.should be_an_instance_of Fixnum
+            locked-= 1
+          end
+        end
+      end
+      ::EM::Synchrony.sleep 0.25
+      locked = false
+      mutex.owned?.should be_true
+      mutex.unlock.should be_an_instance_of described_class
+      mutex.owned?.should be_false
+      ::EM::Synchrony.sleep 0.1
+
+      locked = true
+      mutex.lock.should be true
+      ::EM::Synchrony.sleep 0.25
+      locked = 10
+      mutex.unlock.should be_an_instance_of described_class
+      ::EM::Synchrony.sleep 0.1
+      locked.should eq 0
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should lock and prevent other fibers to lock on the same semaphore with block timeout" do
+    begin
+      mutex = described_class.lock(*@lock_names)
+      mutex.should be_an_instance_of described_class
+      mutex.owned?.should be_true
+      locked = true
+      ::EM::Synchrony.next_tick do
+        start = Time.now
+        mutex.lock(0.25).should be false
+        mutex.owned?.should be_false
+        (Time.now - start).should be_within(0.01).of(0.26)
+        locked.should be true
+        locked = nil
+      end
+      ::EM::Synchrony.sleep 0.26
+      locked.should be_nil
+      locked = false
+      mutex.locked?.should be_true
+      mutex.owned?.should be_true
+      mutex.unlock.should be_an_instance_of described_class
+      mutex.locked?.should be_false
+      mutex.owned?.should be_false
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should lock and expire while other fiber lock on the same semaphore with block timeout" do
+    begin
+      mutex = described_class.lock(*@lock_names, expire: 0.2499999)
+      mutex.expire_timeout.should eq 0.2499999
+      mutex.should be_an_instance_of described_class
+      mutex.owned?.should be_true
+      locked = true
+      ::EM::Synchrony.next_tick do
+        mutex.owned?.should be_false
+        start = Time.now
+        mutex.lock(0.25).should be true
+        (Time.now - start).should be_within(0.011).of(0.26)
+        locked.should be true
+        locked = nil
+        mutex.locked?.should be_true
+        mutex.owned?.should be_true
+        ::EM::Synchrony.sleep 0.2
+        locked.should be_false
+        mutex.unlock.should be_an_instance_of described_class
+        mutex.owned?.should be_false
+        mutex.locked?.should be_false
+      end
+      ::EM::Synchrony.sleep 0.26
+      locked.should be_nil
+      locked = false
+      mutex.locked?.should be_true
+      mutex.owned?.should be_false
+      mutex.unlock.should be_an_instance_of described_class
+      mutex.locked?.should be_true
+      mutex.owned?.should be_false
+      ::EM::Synchrony.sleep 0.2
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should lock and prevent (with refresh) other fibers to lock on the same semaphore with block timeout" do
+    begin
+      mutex = described_class.lock(*@lock_names, expire: 0.11)
+      mutex.should be_an_instance_of described_class
+      mutex.owned?.should be_true
+      locked = true
+      ::EM::Synchrony.next_tick do
+        start = Time.now
+        mutex.lock(0.3).should be false
+        mutex.owned?.should be_false
+        (Time.now - start).should be_within(0.01).of(0.31)
+        locked.should be true
+        locked = nil
+      end
+      ::EM::Synchrony.sleep 0.08
+      mutex.owned?.should be_true
+      mutex.refresh
+      ::EM::Synchrony.sleep 0.08
+      mutex.owned?.should be_true
+      mutex.refresh(0.5)
+      ::EM::Synchrony.sleep 0.15
+      locked.should be_nil
+      locked = false
+      mutex.locked?.should be_true
+      mutex.owned?.should be_true
+      mutex.unlock.should be_an_instance_of described_class
+      mutex.locked?.should be_false
+      mutex.owned?.should be_false
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should lock some resource and play with it safely" do
+    mutex = described_class.new(*@lock_names)
+    play_name = SecureRandom.random_bytes
+    result = []
+    ::EM::Synchrony::FiberIterator.new((0..9).to_a, 10).each do |i|
+      was_locked = false
+      redis = Redis.new @redis_options
+      mutex.owned?.should be_false
+      mutex.synchronize do
+        mutex.owned?.should be_true
+        was_locked = true
+        redis.setnx(play_name, i).should be_true
+        ::EM::Synchrony.sleep 0.1
+        redis.get(play_name).should eq i.to_s
+        redis.del(play_name).should eq 1
+      end
+      was_locked.should be_true
+      mutex.owned?.should be_false
+      result << i
+    end
+    mutex.locked?.should be_false
+    result.sort.should eq (0..9).to_a
+  end
+
+  it "should lock and the other fiber should acquire lock as soon as possible" do
+    mutex = described_class.lock(*@lock_names)
+    mutex.should be_an_instance_of described_class
+    time = nil
+    EM::Synchrony.next_tick do
+      time.should be_nil
+      was_locked = false
+      mutex.synchronize do
+        time.should be_an_instance_of Time
+        (Time.now - time).should be < 0.0009
+        was_locked = true
+      end
+      was_locked.should be_true
+    end
+    EM::Synchrony.sleep 0.1
+    mutex.owned?.should be_true
+    mutex.unlock.should be_an_instance_of described_class
+    time = Time.now
+    mutex.owned?.should be_false
+    EM::Synchrony.sleep 0.1
+  end
+
+  it "should lock and the other process should acquire lock as soon as possible" do
+    mutex = described_class.lock(*@lock_names)
+    mutex.should be_an_instance_of described_class
+    time_key1 = SecureRandom.random_bytes
+    time_key2 = SecureRandom.random_bytes
+    ::EM.fork_reactor do
+      Fiber.new do
+        begin
+          redis = Redis.new @redis_options
+          redis.set time_key1, Time.now.to_f.to_s
+          mutex.synchronize do
+            redis.set time_key2, Time.now.to_f.to_s
+          end
+          described_class.stop_watcher(false)
+        # rescue => e
+        #   warn e.inspect
+        ensure
+          EM.stop
+        end
+      end.resume
+    end
+    EM::Synchrony.sleep 0.25
+    mutex.owned?.should be_true
+    mutex.unlock.should be_an_instance_of described_class
+    time = Time.now.to_f
+    mutex.owned?.should be_false
+    EM::Synchrony.sleep 0.25
+    redis = Redis.new @redis_options
+    t1, t2 = redis.mget(time_key1, time_key2)
+    t1.should be_an_instance_of String
+    t1.to_f.should be < time - 0.25
+    t2.should be_an_instance_of String
+    t2.to_f.should be > time
+    t2.to_f.should be_within(0.001).of(time)
+    redis.del(time_key1, time_key2)
+  end
+
+  around(:each) do |testcase|
+    @after_em_stop = nil
+    ::EM.synchrony do
+      begin
+        testcase.call
+      ensure
+        described_class.stop_watcher(false)
+        ::EM.stop
+      end
+    end
+    @after_em_stop.call if @after_em_stop
+  end
+
+  before(:all) do
+    @redis_options = {}
+    described_class.setup @redis_options.merge(size: 11)
+    @lock_names = 10.times.map {
+      SecureRandom.random_bytes
+    }
+  end
+
+  after(:all) do
+    # @lock_names
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: redis-em-mutex
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Rafal Michalski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &204598440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *204598440
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: &204597980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *204597980
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &204597520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *204597520
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &204597060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *204597060
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &204596600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.1
+  type: :development
+  prerelease: false
+  version_requirements: *204596600
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: &204596140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *204596140
+description: Cross server-process-fiber EventMachine + Redis based semaphore with
+  many features
+email: rafal@yeondir.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- Rakefile
+- lib/redis-em-mutex.rb
+- lib/redis/em-mutex.rb
+- redis-em-mutex.gemspec
+- spec/redis-em-mutex-features.rb
+- spec/redis-em-mutex-semaphores.rb
+homepage: http://github.com/royaltm/redis-em-mutex
+licenses: []
+post_install_message: 
+rdoc_options:
+- --title
+- redis-em-mutex
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Redis server
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Cross server-process-fiber EventMachine + Redis based semaphore
+test_files:
+- spec/redis-em-mutex-semaphores.rb
+- spec/redis-em-mutex-features.rb