em-hiredis 0.2.1 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 48fe707c4b77c8666f0466d1a33f342222f01341
+  data.tar.gz: f9119b5ab7ad4af24a98f8392556f85813c1baf0
+SHA512:
+  metadata.gz: 0039ac23a12e4027902ea932b5f518be4a4ddfcf553a7cdb30103a46d465f35b2954be053135e26d90eea4c2d2f922ff550925ce89a14191a0d800d1b05b41ca
+  data.tar.gz: 3c5a950d9abbde1c1b1ef55a359f7804d9128b9f6527a43b5126423fc70d7c0a809fedd7dbe482a430db8f177cf2eb1f25c4013414b3fd78ee99c3c6b22d24a5

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.3.0 (2014-06-30)
+
+[NEW] Lua script support (see README for details).
+
+[NEW] `Client#reconnect!` method which disconnects, reconfigures, and reconnects.
+
+[CHANGED] Locking abstraction re-implemented using lua (safer and simpler) [mdpye].
+
+[CHANGED] Hiredis dependency updated to 0.5.x
+
 ## 0.2.1 (2013-04-22)
 
 [NEW] Support for connecting to redis on a unix socket.

data/README.md

@@ -67,7 +67,7 @@ The regular `EM::Hiredis::Client` no longer understands pubsub messages - this l
 
 Pubsub can either be used in em-hiredis in a close-to-the-metal fashion, or you can use the convenience functionality for binding blocks to subscriptions if you prefer (recommended).
 
-### Close to the metal
+### Close to the metal pubsub interface
 
 Basically just bind to `:message` and `:pmessage` events:
 
@@ -92,7 +92,7 @@ Basically just bind to `:message` and `:pmessage` events:
       }
     }
 
-### Richer interface to pubsub
+### Richer pubsub interface
 
 If you pass a block to `subscribe` or `psubscribe`, the passed block will be called whenever a message arrives on that subscription:
 
@@ -118,19 +118,43 @@ If you pass a block to `subscribe` or `psubscribe`, the passed block will be cal
 
 It's possible to subscribe to the same channel multiple time and just unsubscribe a single callback using `unsubscribe_proc` or `punsubscribe_proc`.
 
-## Developing
+## Lua
+
+You can of course call EVAL or EVALSHA directly; the following is a higher-level API.
+
+Registering a named command on a redis client defines a ruby method with the given name on the client:
+
+    redis.register_script(:multiply, <<-END)
+      return redis.call('get', KEYS[1]) * ARGV[1]
+    END
+
+The method can be called in a very similar way to any other redis command; the only difference is that the first argument must be an array of keys, and the second (optional) an array of values.
+
+    # Multiplies the value at key foo by 2
+    redis.multiply(['foo'], [2]).callback { ... }
 
-Hacking on em-hiredis is pretty simple, make sure you have Bundler installed:
+Lua commands are submitted to redis using EVALSHA for efficiency. If redis replies with a NOSCRIPT error, the command is automatically re-submitted with EVAL; this is totally transparent to your code and the intermediate 'failure' will not be passed to your errback.
 
-    gem install bundler
-    bundle
+You may register scripts globally, in which case they will be available to all clients:
+
+    EM::Hiredis::Client.register_script(:multiply, <<-END)
+      return redis.call('get', KEYS[1]) * ARGV[1]
+    END
+
+As a final convenience, it is possible to load all lua scripts from a directory automatically. All `.lua` files in the directory will be registered, and named according to filename (so a file called `sum.lua` becomes available as `redis.sum(...)`).
+
+    EM::Hiredis::Client.load_scripts_from('./lua_scripts')
+
+For examples see `examples/lua.rb` or `lib/em-hiredis/lock_lua`.
+
+## Developing
 
-In order to run the tests you need to have a local redis server running on port 6379. Run all the tests:
+You need bundler and a local redis server running on port 6379 to run the test suite.
 
     # WARNING: The tests call flushdb on db 9 - this clears all keys!
-    bundle exec rake 
+    bundle exec rake
 
-To run an individual test:
+Run an individual spec:
 
     bundle exec rspec spec/redis_commands_spec.rb
 

data/em-hiredis.gemspec

@@ -12,7 +12,8 @@ Gem::Specification.new do |s|
   s.summary     = %q{Eventmachine redis client}
   s.description = %q{Eventmachine redis client using hiredis native parser}
 
-  s.add_dependency 'hiredis', '~> 0.4.0'
+  s.add_dependency 'eventmachine', '~> 1.0'
+  s.add_dependency 'hiredis', '~> 0.5.0'
 
   s.add_development_dependency 'em-spec', '~> 0.2.5'
   s.add_development_dependency 'rspec', '~> 2.6.0'

data/examples/lua/sum.lua

@@ -0,0 +1,4 @@
+local a = redis.call('get', KEYS[1])
+local b = redis.call('get', KEYS[2])
+
+return a + b

data/examples/lua_example.rb

@@ -0,0 +1,35 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'em-hiredis'
+
+EM.run do
+  scripts_dir = File.expand_path("../lua", __FILE__)
+  EM::Hiredis::Client.load_scripts_from(scripts_dir)
+
+  redis = EM::Hiredis.connect
+
+  redis.register_script(:multiply, <<-END)
+    return redis.call('get', KEYS[1]) * ARGV[1]
+  END
+
+  redis.set('foo', 42).callback {
+    redis.set('bar', 8).callback {
+
+      # Multiply is defined above.
+      # It is passed one key and one argument.
+      redis.multiply(['foo'], [2]).callback { |v|
+        puts "Multiply returned: #{v}"
+      }.errback { |e|
+        puts "Multiply error: #{e}"
+      }
+
+      # Sum is a lua script defined in sum.lua.
+      # It is passed two keys.
+      redis.sum(['foo', 'bar']).callback { |sum|
+        puts "Sum returned: #{sum}"
+      }.errback { |e|
+        puts "Sum error: #{e}"
+      }
+
+    }
+  }
+end

data/lib/em-hiredis/base_client.rb

@@ -21,7 +21,6 @@ module EventMachine::Hiredis
       @defs = []
       @command_queue = []
 
-      @closing_connection = false
       @reconnect_failed_count = 0
       @reconnect_timer = nil
       @failed = false
@@ -55,7 +54,21 @@ module EventMachine::Hiredis
       end
     end
 
+    # Disconnect then reconnect the redis connection.
+    #
+    # Pass optional uri - e.g. to connect to a different redis server.
+    # Any pending redis commands will be failed, but during the reconnection
+    # new commands will be queued and sent after connected.
+    #
+    def reconnect!(new_uri = nil)
+      @connection.close_connection
+      configure(new_uri) if new_uri
+      @auto_reconnect = true
+      EM.next_tick { reconnect_connection }
+    end
+
     def connect
+      @auto_reconnect = true
       @connection = EM.connect(@host, @port, Connection, @host, @port)
 
       @connection.on(:closed) do
@@ -64,14 +77,14 @@ module EventMachine::Hiredis
           @defs = []
           @deferred_status = nil
           @connected = false
-          unless @closing_connection
+          if @auto_reconnect
             # Next tick avoids reconnecting after for example EM.stop
             EM.next_tick { reconnect }
           end
           emit(:disconnected)
           EM::Hiredis.logger.info("#{@connection} Disconnected")
         else
-          unless @closing_connection
+          if @auto_reconnect
             @reconnect_failed_count += 1
             @reconnect_timer = EM.add_timer(EM::Hiredis.reconnect_timeout) {
               @reconnect_timer = nil
@@ -156,11 +169,14 @@ module EventMachine::Hiredis
 
     def close_connection
       EM.cancel_timer(@reconnect_timer) if @reconnect_timer
-      @closing_connection = true
+      @auto_reconnect = false
       @connection.close_connection_after_writing
     end
 
+    # Note: This method doesn't disconnect if already connected. You probably
+    # want to use `reconnect!`
     def reconnect_connection
+      @auto_reconnect = true
       EM.cancel_timer(@reconnect_timer) if @reconnect_timer
       reconnect
     end

data/lib/em-hiredis/client.rb

@@ -1,9 +1,50 @@
+require 'digest/sha1'
+
 module EventMachine::Hiredis
   class Client < BaseClient
     def self.connect(host = 'localhost', port = 6379)
       new(host, port).connect
     end
 
+    def self.load_scripts_from(dir)
+      Dir.glob("#{dir}/*.lua").each do |f|
+        name = Regexp.new(/([^\/]*)\.lua$/).match(f)[1]
+        lua = File.open(f, 'r').read
+        EM::Hiredis.logger.debug { "Registering script: #{name}" }
+        EM::Hiredis::Client.register_script(name, lua)
+      end
+    end
+
+    def self.register_script(name, lua)
+      sha = Digest::SHA1.hexdigest(lua)
+      self.send(:define_method, name.to_sym) { |keys, args=[]|
+        eval_script(lua, sha, keys, args)
+      }
+    end
+
+    def register_script(name, lua)
+      sha = Digest::SHA1.hexdigest(lua)
+      singleton = class << self; self end
+      singleton.send(:define_method, name.to_sym) { |keys, args=[]|
+        eval_script(lua, sha, keys, args)
+      }
+    end
+
+    def eval_script(lua, lua_sha, keys, args)
+      df = EM::DefaultDeferrable.new
+      method_missing(:evalsha, lua_sha, keys.size, *keys, *args).callback(
+        &df.method(:succeed)
+      ).errback { |e|
+        if e.kind_of?(RedisError) && e.redis_error.message.start_with?("NOSCRIPT")
+          self.eval(lua, keys.size, *keys, *args)
+            .callback(&df.method(:succeed)).errback(&df.method(:fail))
+        else
+          df.fail(e)
+        end
+      }
+      df
+    end
+
     def monitor(&blk)
       @monitoring = true
       method_missing(:monitor, &blk)

data/lib/em-hiredis/lock.rb

@@ -1,35 +1,52 @@
+require 'securerandom'
+
 module EM::Hiredis
-  # Distributed lock built on redis
+  # Cross-process re-entrant lock, backed by redis
   class Lock
-    # Register an callback which will be called 1s before the lock expires
+
+    EM::Hiredis::Client.load_scripts_from(File.expand_path("../lock_lua", __FILE__))
+
+    # Register a callback which will be called 1s before the lock expires
+    # This is an informational callback, there is no hard guarantee on the timing
+    # of its invocation because the callback firing and lock key expiry are handled
+    # by different clocks (the client process and redis server respectively)
     def onexpire(&blk); @onexpire = blk; end
 
     def initialize(redis, key, timeout)
+      unless timeout.kind_of?(Fixnum) && timeout >= 1
+        raise "Timeout must be an integer and >= 1s"
+      end
       @redis, @key, @timeout = redis, key, timeout
-      @locked = false
-      @expiry = nil
+      @token = SecureRandom.hex
     end
 
     # Acquire the lock
     #
-    # It is ok to call acquire again before the lock expires, which will attempt to extend the existing lock.
+    # This is a re-entrant lock, re-acquiring will succeed and extend the timeout
     #
-    # Returns a deferrable which either succeeds if the lock can be acquired, or fails if it cannot. In both cases the expiry timestamp is returned (for the new lock or for the expired one respectively)
+    # Returns a deferrable which either succeeds if the lock can be acquired, or fails if it cannot.
     def acquire
       df = EM::DefaultDeferrable.new
-      expiry = new_expiry
-      @redis.setnx(@key, expiry).callback { |setnx|
-        if setnx == 1
-          lock_acquired(expiry)
-          EM::Hiredis.logger.debug "#{to_s} Acquired new lock"
-          df.succeed(expiry)
+      @redis.lock_acquire([@key], [@token, @timeout]).callback { |success|
+        if (success)
+          EM::Hiredis.logger.debug "#{to_s} acquired"
+
+          EM.cancel_timer(@expire_timer) if @expire_timer
+          @expire_timer = EM.add_timer(@timeout - 1) {
+            EM::Hiredis.logger.debug "#{to_s} Expires in 1s"
+            @onexpire.call if @onexpire
+          }
+
+          df.succeed
         else
-          attempt_to_acquire_existing_lock(df)
+          EM::Hiredis.logger.debug "#{to_s} failed to acquire"
+          df.fail("Lock is not available")
         end
       }.errback { |e|
+        EM::Hiredis.logger.error "#{to_s} Error acquiring lock #{e}"
         df.fail(e)
       }
-      return df
+      df
     end
 
     # Release the lock
@@ -37,23 +54,29 @@ module EM::Hiredis
     # Returns a deferrable
     def unlock
       EM.cancel_timer(@expire_timer) if @expire_timer
-      
-      unless active
-        df = EM::DefaultDeferrable.new
-        df.fail Error.new("Cannot unlock, lock not active")
-        return df
-      end
 
-      @redis.del(@key)
-    end
-
-    # Lock has been acquired and we're within it's expiry time
-    def active
-      @locked && Time.now.to_i < @expiry
+      df = EM::DefaultDeferrable.new
+      @redis.lock_release([@key], [@token]).callback { |keys_removed|
+        if keys_removed > 0
+          EM::Hiredis.logger.debug "#{to_s} released"
+          df.succeed
+        else
+          EM::Hiredis.logger.debug "#{to_s} could not release, not held"
+          df.fail("Cannot release a lock we do not hold")
+        end
+      }.errback { |e|
+        EM::Hiredis.logger.error "#{to_s} Error releasing lock #{e}"
+        df.fail(e)
+      }
+      df
     end
 
-    # This should not be used in normal operation - force clear
+    # This should not be used in normal operation.
+    # Force clear without regard to who owns the lock.
     def clear
+      EM::Hiredis.logger.warn "#{to_s} Force clearing lock (unsafe)"
+      EM.cancel_timer(@expire_timer) if @expire_timer
+
       @redis.del(@key)
     end
 
@@ -61,46 +84,5 @@ module EM::Hiredis
       "[lock #{@key}]"
     end
 
-    private
-
-    def attempt_to_acquire_existing_lock(df)
-      @redis.get(@key) { |expiry_1|
-        expiry_1 = expiry_1.to_i
-        if expiry_1 == @expiry || expiry_1 < Time.now.to_i
-          # Either the lock was ours or the lock has already expired
-          expiry = new_expiry
-          @redis.getset(@key, expiry) { |expiry_2|
-            expiry_2 = expiry_2.to_i
-            if expiry_2 == @expiry || expiry_2 < Time.now.to_i
-              lock_acquired(expiry)
-              EM::Hiredis.logger.debug "#{to_s} Acquired existing lock"
-              df.succeed(expiry)
-            else
-              # Another client got there first
-              EM::Hiredis.logger.debug "#{to_s} Could not acquire - another process acquired while we were in the process of acquiring"
-              df.fail(expiry_2)
-            end
-          }
-        else
-          # Someone else has an active lock
-          EM::Hiredis.logger.debug "#{to_s} Could not acquire - held by another process"
-          df.fail(expiry_1)
-        end
-      }
-    end
-
-    def new_expiry
-      Time.now.to_i + @timeout + 1
-    end
-
-    def lock_acquired(expiry)
-      @locked = true
-      @expiry = expiry
-      EM.cancel_timer(@expire_timer) if @expire_timer
-      @expire_timer = EM.add_timer(@timeout) {
-        EM::Hiredis.logger.debug "#{to_s} Expires in 1s"
-        @onexpire.call if @onexpire
-      }
-    end
   end
 end

data/lib/em-hiredis/lock_lua/lock_acquire.lua

@@ -0,0 +1,17 @@
+-- Set key to token with expiry of timeout, if:
+--  - It doesn't exist
+--  - It exists and already has value of token (further set extends timeout)
+-- Used to implement a re-entrant lock.
+local key = KEYS[1]
+local token = ARGV[1]
+local timeout = ARGV[2]
+
+local value = redis.call('get', key)
+
+if value == token or not value then
+    -- Great, either we hold the lock or it's free for us to take
+    return redis.call('setex', key, timeout, token)
+else
+    -- Someone else has it
+    return false
+end

data/lib/em-hiredis/lock_lua/lock_release.lua

@@ -0,0 +1,9 @@
+-- Deletes a key only if it has the value supplied as token
+local key = KEYS[1]
+local token = ARGV[1]
+
+if redis.call('get', key) == token then
+    return redis.call('del', key)
+else
+    return 0
+end

data/lib/em-hiredis/persistent_lock.rb

@@ -21,11 +21,8 @@ module EM::Hiredis
       @redis, @key = redis, key
       @timeout = options[:lock_timeout] || 100
       @retry_timeout = options[:retry_interval] || 60
+
       @lock = EM::Hiredis::Lock.new(redis, key, @timeout)
-      @lock.onexpire {
-        # When the lock is about to expire, extend (called 1s before expiry)
-        acquire()
-      }
       @locked = false
       EM.next_tick {
         @running = true
@@ -42,6 +39,11 @@ module EM::Hiredis
           @onlocked.call if @onlocked
           @locked = true
         end
+
+        # Re-acquire lock near the end of the period
+        @extend_timer = EM.add_timer(@timeout.to_f * 2 / 3) {
+          acquire()
+        }
       }.errback { |e|
         if @locked
           # We were previously locked
@@ -54,7 +56,7 @@ module EM::Hiredis
           EM::Hiredis.logger.warn "Unexpected error acquiring #{@lock} #{err}"
         end
 
-        EM.add_timer(@retry_timeout) {
+        @retry_timer = EM.add_timer(@retry_timeout) {
           acquire() unless @locked
         }
       }
@@ -62,6 +64,8 @@ module EM::Hiredis
 
     def stop
       @running = false
+      EM.cancel_timer(@extend_timer) if @extend_timer
+      EM.cancel_timer(@retry_timer) if @retry_timer
       if @locked
         # We were previously locked
         @onunlocked.call if @onunlocked

data/lib/em-hiredis/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
   module Hiredis
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/spec/base_client_spec.rb

@@ -105,7 +105,7 @@ describe EM::Hiredis::BaseClient do
         df.errback { |e|
           e.class.should == EM::Hiredis::RedisError
           e.should be_kind_of(EM::Hiredis::Error)
-          msg = "ERR Operation against a key holding the wrong kind of value"
+          msg = "WRONGTYPE Operation against a key holding the wrong kind of value"
           e.message.should == msg
           # This is the wrapped error from redis:
           e.redis_error.class.should == RuntimeError

data/spec/lock_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe EventMachine::Hiredis::Lock do
+
+  def start(timeout = 1)
+    connect(timeout) do |redis|
+      @redis = redis
+      yield
+    end
+  end
+
+  def new_lock
+    EventMachine::Hiredis::Lock.new(@redis, "test-lock", 2)
+  end
+
+  it "can be acquired" do
+    start {
+      new_lock.acquire.callback {
+        done
+      }.errback { |e|
+        fail e
+      }
+    }
+  end
+
+  it "is re-entrant" do
+    start {
+      lock = new_lock
+      lock.acquire.callback {
+        lock.acquire.callback {
+          done
+        }.errback { |e|
+          fail e
+        }
+      }.errback { |e|
+        fail e
+      }
+    }
+  end
+
+  it "is exclusive" do
+    start {
+      new_lock.acquire.callback {
+        new_lock.acquire.errback {
+          done
+        }.callback {
+          fail "Should not be able to acquire lock from different client"
+        }
+      }.errback { |e|
+        fail e
+      }
+    }
+  end
+
+  it "can be released and taken by another instance" do
+    start {
+      lock = new_lock
+      lock.acquire.callback {
+        lock.unlock.callback {
+          new_lock.acquire.callback {
+            done
+          }.errback { |e|
+            fail e
+          }
+        }.errback { |e|
+          fail e
+        }
+      }.errback { |e|
+        fail e
+      }
+    }
+  end
+
+  it "times out" do
+    start(3) {
+      new_lock.acquire.callback {
+        EM.add_timer(2) {
+          new_lock.acquire.callback {
+            done
+          }.errback { |e|
+            fail e
+          }
+        }
+      }.errback { |e|
+        fail e
+      }
+    }
+  end
+
+  it "extends timeout on re-entry" do
+    start(4) {
+      lock = new_lock
+      lock.acquire.callback {
+        EM.add_timer(1) {
+          lock.acquire.callback {
+            EM.add_timer(1.5) {
+              # Check it's still locked by initial instance
+              new_lock.acquire.errback {
+                done
+              }.callback { |e|
+                fail e
+              }
+            }
+          }.errback { |e|
+            fail e
+          }
+        }
+      }.errback { |e|
+        fail e
+      }
+    }
+  end
+
+  it "fails to release if it has not been taken" do
+    start {
+      new_lock.unlock.errback {
+        done
+      }.callback {
+        fail "Released lock which had not been taken"
+      }
+    }
+  end
+
+  it "fails to release if taken by another instance" do
+    start {
+      new_lock.acquire.callback {
+        new_lock.unlock.errback {
+          done
+        }.callback {
+          fail "Released lock belonging to another instance"
+        }
+      }.errback { |e|
+        fail e
+      }
+    }
+  end
+end

metadata

@@ -1,78 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: em-hiredis
 version: !ruby/object:Gem::Version
-  version: 0.2.1
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Martyn Loughran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-22 00:00:00.000000000 Z
+date: 2014-06-30 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: hiredis
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: em-spec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.5
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.6.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.6.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Eventmachine redis client using hiredis native parser
@@ -82,8 +87,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
+- ".gitignore"
+- ".rspec"
 - CHANGELOG.md
 - Gemfile
 - LICENCE
@@ -91,6 +96,8 @@ files:
 - Rakefile
 - em-hiredis.gemspec
 - examples/getting_started.rb
+- examples/lua/sum.lua
+- examples/lua_example.rb
 - examples/pubsub_basics.rb
 - examples/pubsub_more.rb
 - examples/pubsub_raw.rb
@@ -100,12 +107,15 @@ files:
 - lib/em-hiredis/connection.rb
 - lib/em-hiredis/event_emitter.rb
 - lib/em-hiredis/lock.rb
+- lib/em-hiredis/lock_lua/lock_acquire.lua
+- lib/em-hiredis/lock_lua/lock_release.lua
 - lib/em-hiredis/persistent_lock.rb
 - lib/em-hiredis/pubsub_client.rb
 - lib/em-hiredis/version.rb
 - spec/base_client_spec.rb
 - spec/connection_spec.rb
 - spec/live_redis_protocol_spec.rb
+- spec/lock_spec.rb
 - spec/pubsub_spec.rb
 - spec/redis_commands_spec.rb
 - spec/spec_helper.rb
@@ -114,38 +124,32 @@ files:
 - spec/url_param_spec.rb
 homepage: http://github.com/mloughran/em-hiredis
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3658727761083238148
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3658727761083238148
 requirements: []
 rubyforge_project: em-hiredis
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Eventmachine redis client
 test_files:
 - spec/base_client_spec.rb
 - spec/connection_spec.rb
 - spec/live_redis_protocol_spec.rb
+- spec/lock_spec.rb
 - spec/pubsub_spec.rb
 - spec/redis_commands_spec.rb
 - spec/spec_helper.rb