suo-dependless 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a874831b56f527f3e7bd154e5b7811be14580c7d
+  data.tar.gz: 03eb5515ae43d4ac7bb6fc1c6da82629f9831cb2
+SHA512:
+  metadata.gz: 851915fd21541fc735e2c7053d88e47d5cdb02fd8036fa56ce2cccc492fe2c39477916fda2dffa443d186913e09e9aac71fb7036f9fa91bd13825f6dfea14e0c
+  data.tar.gz: 3c1f9ebd4f654d64eef795ecfe81a15ec335e617c71b1af01f08e1b59693c75b81a73aa453106f6afab03c8de80b7f6c726e422d32e5882c18bf1f457d79dc9c

data/.gitignore

@@ -0,0 +1,18 @@
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rubocop.yml

@@ -0,0 +1,219 @@
+AllCops:
+  Exclude:
+    - .git/**/*
+    - tmp/**/*
+    - suo.gemspec
+
+Lint/DuplicateMethods:
+  Enabled: true
+
+Lint/DeprecatedClassMethods:
+  Enabled: true
+
+Style/TrailingWhitespace:
+  Enabled: true
+
+Style/Tab:
+  Enabled: true
+
+Style/TrailingBlankLines:
+  Enabled: true
+
+Style/NilComparison:
+  Enabled: true
+
+Style/NonNilCheck:
+  Enabled: true
+
+Style/Not:
+  Enabled: true
+
+Style/RedundantReturn:
+  Enabled: true
+
+Style/ClassCheck:
+  Enabled: true
+
+Style/EmptyLines:
+  Enabled: true
+
+Style/EmptyLiteral:
+  Enabled: true
+
+Style/Alias:
+  Enabled: true
+
+Style/MethodCallParentheses:
+  Enabled: true
+
+Style/MethodDefParentheses:
+  Enabled: true
+
+Style/SpaceBeforeBlockBraces:
+  Enabled: true
+
+Style/SpaceInsideBlockBraces:
+  Enabled: true
+
+Style/SpaceInsideParens:
+  Enabled: true
+
+Style/DeprecatedHashMethods:
+  Enabled: true
+
+Style/HashSyntax:
+  Enabled: true
+
+Style/SpaceInsideHashLiteralBraces:
+  Enabled: true
+  EnforcedStyle: no_space
+
+Style/SpaceInsideBrackets:
+  Enabled: true
+
+Style/AndOr:
+  Enabled: false
+
+Style/TrailingCommaInLiteral:
+  Enabled: true
+
+Style/SpaceBeforeComma:
+  Enabled: true
+
+Style/SpaceBeforeComment:
+  Enabled: true
+
+Style/SpaceBeforeSemicolon:
+  Enabled: true
+
+Style/SpaceAroundBlockParameters:
+  Enabled: true
+
+Style/SpaceAroundOperators:
+  Enabled: true
+
+Style/SpaceAfterColon:
+  Enabled: true
+
+Style/SpaceAfterComma:
+  Enabled: true
+
+Style/SpaceAroundKeyword:
+  Enabled: true
+
+Style/SpaceAfterNot:
+  Enabled: true
+
+Style/SpaceAfterSemicolon:
+  Enabled: true
+
+Lint/UselessComparison:
+  Enabled: true
+
+Lint/InvalidCharacterLiteral:
+  Enabled: true
+
+Lint/LiteralInInterpolation:
+  Enabled: true
+
+Lint/LiteralInCondition:
+  Enabled: true
+
+Lint/UnusedBlockArgument:
+  Enabled: true
+
+Style/VariableInterpolation:
+  Enabled: true
+
+Style/RedundantSelf:
+  Enabled: true
+
+Style/ParenthesesAroundCondition:
+  Enabled: true
+
+Style/WhileUntilDo:
+  Enabled: true
+
+Style/EmptyLineBetweenDefs:
+  Enabled: true
+
+Style/EmptyLinesAroundAccessModifier:
+  Enabled: true
+
+Style/EmptyLinesAroundMethodBody:
+  Enabled: true
+
+Style/ColonMethodCall:
+  Enabled: true
+
+Lint/SpaceBeforeFirstArg:
+  Enabled: true
+
+Lint/UnreachableCode:
+  Enabled: true
+
+Style/UnlessElse:
+  Enabled: true
+
+Style/ClassVars:
+  Enabled: true
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Metrics/CyclomaticComplexity:
+  Max: 10
+
+Metrics/LineLength:
+  Max: 128
+
+Metrics/MethodLength:
+  Max: 32
+
+Metrics/PerceivedComplexity:
+  Max: 8
+
+# Disabled
+
+Style/EvenOdd:
+  Enabled: false
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/UnneededPercentQ:
+  Enabled: false
+
+Style/SpecialGlobalVars:
+  Enabled: false
+
+Style/TrivialAccessors:
+  Enabled: false
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.3.1
+services:
+  - memcached
+  - redis-server

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+## 0.3.2
+
+- Custom lock tokens (thanks to avokhmin).
+
+## 0.3.1
+
+- Slight memory leak fix.
+
+## 0.3.0
+
+- Dramatically simplify the interface by forcing clients to specify the key & resources at lock initialization instead of every method call.
+
+## 0.2.3
+
+- Clarify documentation further with respect to semaphores.
+
+## 0.2.2
+
+- Fix bug with refresh - typo would've prevented real use.
+- Clean up code.
+- Improve documentation a bit.
+- 100% test coverage.
+
+## 0.2.1
+
+- Fix bug when dealing with real-world Redis error conditions.
+
+## 0.2.0
+
+- Refactor class methods into instance methods to simplify implementation.
+- Increase thread safety with Memcached implementation.
+
+## 0.1.3
+
+- Properly throw Suo::LockClientError when the connection itself fails (Memcache server not reachable, etc.)
+
+## 0.1.2
+
+- Fix retry_timeout to properly use the full time (was being calculated incorrectly).
+- Refactor client implementations to re-use more code.
+
+## 0.1.1
+
+- Use [MessagePack](https://github.com/msgpack/msgpack-ruby) for lock serialization.
+
+## 0.1.0
+
+- First release.

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Nick Elser
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,89 @@
+# Suo [![Build Status](https://travis-ci.org/nickelser/suo.svg?branch=master)](https://travis-ci.org/nickelser/suo) [![Code Climate](https://codeclimate.com/github/nickelser/suo/badges/gpa.svg)](https://codeclimate.com/github/nickelser/suo) [![Test Coverage](https://codeclimate.com/github/nickelser/suo/badges/coverage.svg)](https://codeclimate.com/github/nickelser/suo) [![Gem Version](https://badge.fury.io/rb/suo.svg)](http://badge.fury.io/rb/suo)
+
+:lock: Distributed semaphores using Memcached or Redis in Ruby.
+
+Suo provides a very performant distributed lock solution using Compare-And-Set (`CAS`) commands in Memcached, and `WATCH/MULTI` in Redis. It allows locking both single exclusion (like a mutex - sharing one resource), as well as multiple resources.
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'suo'
+```
+
+## Usage
+
+### Basic
+
+```ruby
+# Memcached
+suo = Suo::Client::Memcached.new("foo_resource", connection: "127.0.0.1:11211")
+
+# Redis
+suo = Suo::Client::Redis.new("baz_resource", connection: {host: "10.0.1.1"})
+
+# Pre-existing client
+suo = Suo::Client::Memcached.new("bar_resource", client: some_dalli_client)
+
+suo.lock do
+  # critical code here
+  @puppies.pet!
+end
+
+# The resources argument is the number of resources the semaphore will allow to lock (defaulting to one - a mutex)
+suo = Suo::Client::Memcached.new("bar_resource", client: some_dalli_client, resources: 2)
+
+Thread.new { suo.lock { puts "One"; sleep 2 } }
+Thread.new { suo.lock { puts "Two"; sleep 2 } }
+Thread.new { suo.lock { puts "Three" } }
+
+# will print "One" "Two", but not "Three", as there are only 2 resources
+
+# custom acquisition timeouts (time to acquire)
+suo = Suo::Client::Memcached.new("protected_key", client: some_dalli_client, acquisition_timeout: 1) # in seconds
+
+# manually locking/unlocking
+# the return value from lock without a block is a unique token valid only for the current lock
+# which must be unlocked manually
+token = suo.lock
+foo.baz!
+suo.unlock(token)
+
+# custom stale lock expiration (cleaning of dead locks)
+suo = Suo::Client::Redis.new("other_key", client: some_redis_client, stale_lock_expiration: 60*5)
+```
+
+### Stale locks
+
+"Stale locks" - those acquired more than `stale_lock_expiration` (defaulting to 3600 or one hour) ago - are automatically cleared during any operation on the key (`lock`, `unlock`, `refresh`). The `locked?` method will not return true if only stale locks exist, but will not modify the key itself.
+
+To re-acquire a lock in the middle of a block, you can use the refresh method on client.
+
+```ruby
+suo = Suo::Client::Redis.new("foo")
+
+# lock is the same token as seen in the manual example, above
+suo.lock do |token|
+  5.times do
+    baz.bar!
+    suo.refresh(token)
+  end
+end
+```
+
+## TODO
+ - more race condition tests
+
+## History
+
+View the [changelog](https://github.com/nickelser/suo/blob/master/CHANGELOG.md).
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/nickelser/suo/issues)
+- Fix bugs and [submit pull requests](https://github.com/nickelser/suo/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task default: :test
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "suo"
+require "irb"
+
+IRB.start

data/bin/setup

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install

data/lib/suo/client/base.rb

@@ -0,0 +1,194 @@
+module Suo
+  module Client
+    class Base
+      DEFAULT_OPTIONS = {
+        acquisition_timeout: 0.1,
+        acquisition_delay: 0.01,
+        stale_lock_expiration: 3600,
+        resources: 1
+      }.freeze
+
+      BLANK_STR = "".freeze
+
+      attr_accessor :client, :key, :resources, :options
+
+      include MonitorMixin
+
+      def initialize(key, options = {})
+        fail "Client required" unless options[:client]
+
+        @options = DEFAULT_OPTIONS.merge(options)
+        @retry_count = (@options[:acquisition_timeout] / @options[:acquisition_delay].to_f).ceil
+        @client = @options[:client]
+        @resources = @options[:resources].to_i
+        @key = key
+
+        super() # initialize Monitor mixin for thread safety
+      end
+
+      def lock(custom_token = nil)
+        token = acquire_lock(custom_token)
+
+        if block_given? && token
+          begin
+            yield
+          ensure
+            unlock(token)
+          end
+        else
+          token
+        end
+      end
+
+      def locked?
+        locks.size >= resources
+      end
+
+      def locks
+        val, _ = get
+        cleared_locks = deserialize_and_clear_locks(val)
+
+        cleared_locks
+      end
+
+      def refresh(token)
+        retry_with_timeout do
+          val, cas = get
+
+          if val.nil?
+            initial_set
+            next
+          end
+
+          cleared_locks = deserialize_and_clear_locks(val)
+
+          refresh_lock(cleared_locks, token)
+
+          break if set(serialize_locks(cleared_locks), cas)
+        end
+      end
+
+      def unlock(token)
+        return unless token
+
+        retry_with_timeout do
+          val, cas = get
+
+          break if val.nil?
+
+          cleared_locks = deserialize_and_clear_locks(val)
+
+          acquisition_lock = remove_lock(cleared_locks, token)
+
+          break unless acquisition_lock
+          break if set(serialize_locks(cleared_locks), cas)
+        end
+      rescue LockClientError => _ # rubocop:disable Lint/HandleExceptions
+        # ignore - assume success due to optimistic locking
+      end
+
+      def clear
+        fail NotImplementedError
+      end
+
+      private
+
+      attr_accessor :retry_count
+
+      def acquire_lock(token = nil)
+        token ||= SecureRandom.base64(16)
+
+        retry_with_timeout do
+          val, cas = get
+
+          if val.nil?
+            initial_set
+            next
+          end
+
+          cleared_locks = deserialize_and_clear_locks(val)
+
+          if cleared_locks.size < resources
+            add_lock(cleared_locks, token)
+
+            newval = serialize_locks(cleared_locks)
+
+            return token if set(newval, cas)
+          end
+        end
+
+        nil
+      end
+
+      def get
+        fail NotImplementedError
+      end
+
+      def set(newval, cas) # rubocop:disable Lint/UnusedMethodArgument
+        fail NotImplementedError
+      end
+
+      def initial_set(val = BLANK_STR) # rubocop:disable Lint/UnusedMethodArgument
+        fail NotImplementedError
+      end
+
+      def synchronize
+        mon_synchronize { yield }
+      end
+
+      def retry_with_timeout
+        start = Time.now.to_f
+
+        retry_count.times do
+          elapsed = Time.now.to_f - start
+          break if elapsed >= options[:acquisition_timeout]
+
+          synchronize do
+            yield
+          end
+
+          sleep(rand(options[:acquisition_delay] * 1000).to_f / 1000)
+        end
+      rescue => _
+        raise LockClientError
+      end
+
+      def serialize_locks(locks)
+        MessagePack.pack(locks.map { |time, token| [time.to_f, token] })
+      end
+
+      def deserialize_and_clear_locks(val)
+        clear_expired_locks(deserialize_locks(val))
+      end
+
+      def deserialize_locks(val)
+        unpacked = (val.nil? || val == BLANK_STR) ? [] : MessagePack.unpack(val)
+
+        unpacked.map do |time, token|
+          [Time.at(time), token]
+        end
+      rescue EOFError, MessagePack::MalformedFormatError => _
+        []
+      end
+
+      def clear_expired_locks(locks)
+        expired = Time.now - options[:stale_lock_expiration]
+        locks.reject { |time, _| time < expired }
+      end
+
+      def add_lock(locks, token, time = Time.now.to_f)
+        locks << [time, token]
+      end
+
+      def remove_lock(locks, acquisition_token)
+        lock = locks.find { |_, token| token == acquisition_token }
+        locks.delete(lock)
+      end
+
+      def refresh_lock(locks, acquisition_token)
+        remove_lock(locks, acquisition_token)
+        add_lock(locks, acquisition_token)
+      end
+    end
+  end
+end

data/lib/suo/client/memcached.rb

@@ -0,0 +1,28 @@
+module Suo
+  module Client
+    class Memcached < Base
+      def initialize(key, options = {})
+        options[:client] ||= Dalli::Client.new(options[:connection] || ENV["MEMCACHE_SERVERS"] || "127.0.0.1:11211")
+        super
+      end
+
+      def clear
+        @client.delete(@key)
+      end
+
+      private
+
+      def get
+        @client.get_cas(@key)
+      end
+
+      def set(newval, cas)
+        @client.set_cas(@key, newval, cas)
+      end
+
+      def initial_set(val = BLANK_STR)
+        @client.set(@key, val)
+      end
+    end
+  end
+end

data/lib/suo/client/redis.rb

@@ -0,0 +1,42 @@
+module Suo
+  module Client
+    class Redis < Base
+      OK_STR = "OK".freeze
+
+      def initialize(key, options = {})
+        options[:client] ||= ::Redis.new(options[:connection] || {})
+        super
+      end
+
+      def clear
+        @client.del(@key)
+      end
+
+      private
+
+      def get
+        [@client.get(@key), nil]
+      end
+
+      def set(newval, _)
+        ret = @client.multi do |multi|
+          multi.set(@key, newval)
+        end
+
+        ret && ret[0] == OK_STR
+      end
+
+      def synchronize
+        @client.watch(@key) do
+          yield
+        end
+      ensure
+        @client.unwatch
+      end
+
+      def initial_set(val = BLANK_STR)
+        @client.set(@key, val)
+      end
+    end
+  end
+end

data/lib/suo/errors.rb

@@ -0,0 +1,3 @@
+module Suo
+  class LockClientError < StandardError; end
+end

data/lib/suo/version.rb

@@ -0,0 +1,3 @@
+module Suo
+  VERSION = "0.3.2".freeze
+end

data/lib/suo.rb

@@ -0,0 +1,16 @@
+require "securerandom"
+require "monitor"
+
+require "dalli"
+require "dalli/cas/client"
+
+require "redis"
+
+require "msgpack"
+
+require "suo/version"
+
+require "suo/errors"
+require "suo/client/base"
+require "suo/client/memcached"
+require "suo/client/redis"

data/suo-dependless.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "suo/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "suo-dependless"
+  spec.version       = Suo::VERSION
+  spec.authors       = ["Nick Elser"]
+  spec.email         = ["nick.elser@gmail.com"]
+
+  spec.summary       = %q(Distributed locks (mutexes & semaphores) using Memcached or Redis.)
+  spec.description   = %q(Distributed locks (mutexes & semaphores) using Memcached or Redis.)
+  spec.homepage      = "https://github.com/bernstein/suo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = "~> 2.0"
+
+  spec.add_dependency "msgpack"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rubocop", "~> 0.30.0"
+  spec.add_development_dependency "minitest", "~> 5.5.0"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 0.4.7"
+end

data/test/client_test.rb

@@ -0,0 +1,397 @@
+require "test_helper"
+
+TEST_KEY = "suo_test_key".freeze
+
+module ClientTests
+  def client(options = {})
+    @client.class.new(options[:key] || TEST_KEY, options.merge(client: @client.client))
+  end
+
+  def test_throws_failed_error_on_bad_client
+    assert_raises(Suo::LockClientError) do
+      client = @client.class.new(TEST_KEY, client: {})
+      client.lock
+    end
+  end
+
+  def test_single_resource_locking
+    lock1 = @client.lock
+    refute_nil lock1
+
+    locked = @client.locked?
+    assert_equal true, locked
+
+    lock2 = @client.lock
+    assert_nil lock2
+
+    @client.unlock(lock1)
+
+    locked = @client.locked?
+
+    assert_equal false, locked
+  end
+
+  def test_lock_with_custom_token
+    token = 'foo-bar'
+    lock  = @client.lock token
+    assert_equal lock, token
+  end
+
+  def test_empty_lock_on_invalid_data
+    @client.send(:initial_set, "bad value")
+    assert_equal false, @client.locked?
+  end
+
+  def test_clear
+    lock1 = @client.lock
+    refute_nil lock1
+
+    @client.clear
+
+    assert_equal false, @client.locked?
+  end
+
+  def test_multiple_resource_locking
+    @client = client(resources: 2)
+
+    lock1 = @client.lock
+    refute_nil lock1
+
+    assert_equal false, @client.locked?
+
+    lock2 = @client.lock
+    refute_nil lock2
+
+    assert_equal true, @client.locked?
+
+    @client.unlock(lock1)
+
+    assert_equal false, @client.locked?
+
+    assert_equal 1, @client.locks.size
+
+    @client.unlock(lock2)
+
+    assert_equal false, @client.locked?
+    assert_equal 0, @client.locks.size
+  end
+
+  def test_block_single_resource_locking
+    locked = false
+
+    @client.lock { locked = true }
+
+    assert_equal true, locked
+  end
+
+  def test_block_unlocks_on_exception
+    assert_raises(RuntimeError) do
+      @client.lock{ fail "Test" }
+    end
+
+    assert_equal false, @client.locked?
+  end
+
+  def test_readme_example
+    output = Queue.new
+    @client = client(resources: 2)
+    threads = []
+
+    threads << Thread.new { @client.lock { output << "One"; sleep 0.5 } }
+    threads << Thread.new { @client.lock { output << "Two"; sleep 0.5 } }
+    sleep 0.1
+    threads << Thread.new { @client.lock { output << "Three" } }
+
+    threads.each(&:join)
+
+    ret = []
+
+    ret << (output.size > 0 ? output.pop : nil)
+    ret << (output.size > 0 ? output.pop : nil)
+
+    ret.sort!
+
+    assert_equal 0, output.size
+    assert_equal %w(One Two), ret
+    assert_equal false, @client.locked?
+  end
+
+  def test_block_multiple_resource_locking
+    success_counter = Queue.new
+    failure_counter = Queue.new
+
+    @client = client(acquisition_timeout: 0.9, resources: 50)
+
+    100.times.map do |i|
+      Thread.new do
+        success = @client.lock do
+          sleep(3)
+          success_counter << i
+        end
+
+        failure_counter << i unless success
+      end
+    end.each(&:join)
+
+    assert_equal 50, success_counter.size
+    assert_equal 50, failure_counter.size
+    assert_equal false, @client.locked?
+  end
+
+  def test_block_multiple_resource_locking_longer_timeout
+    success_counter = Queue.new
+    failure_counter = Queue.new
+
+    @client = client(acquisition_timeout: 3, resources: 50)
+
+    100.times.map do |i|
+      Thread.new do
+        success = @client.lock do
+          sleep(0.5)
+          success_counter << i
+        end
+
+        failure_counter << i unless success
+      end
+    end.each(&:join)
+
+    assert_equal 100, success_counter.size
+    assert_equal 0, failure_counter.size
+    assert_equal false, @client.locked?
+  end
+
+  def test_unstale_lock_acquisition
+    success_counter = Queue.new
+    failure_counter = Queue.new
+
+    @client = client(stale_lock_expiration: 0.5)
+
+    t1 = Thread.new { @client.lock { sleep 0.6; success_counter << 1 } }
+    sleep 0.3
+    t2 = Thread.new do
+      locked = @client.lock { success_counter << 1 }
+      failure_counter << 1 unless locked
+    end
+
+    [t1, t2].each(&:join)
+
+    assert_equal 1, success_counter.size
+    assert_equal 1, failure_counter.size
+    assert_equal false, @client.locked?
+  end
+
+  def test_stale_lock_acquisition
+    success_counter = Queue.new
+    failure_counter = Queue.new
+
+    @client = client(stale_lock_expiration: 0.5)
+
+    t1 = Thread.new { @client.lock { sleep 0.6; success_counter << 1 } }
+    sleep 0.55
+    t2 = Thread.new do
+      locked = @client.lock { success_counter << 1 }
+      failure_counter << 1 unless locked
+    end
+
+    [t1, t2].each(&:join)
+
+    assert_equal 2, success_counter.size
+    assert_equal 0, failure_counter.size
+    assert_equal false, @client.locked?
+  end
+
+  def test_refresh
+    @client = client(stale_lock_expiration: 0.5)
+
+    lock1 = @client.lock
+
+    assert_equal true, @client.locked?
+
+    @client.refresh(lock1)
+
+    assert_equal true, @client.locked?
+
+    sleep 0.55
+
+    assert_equal false, @client.locked?
+
+    lock2 = @client.lock
+
+    @client.refresh(lock1)
+
+    assert_equal true, @client.locked?
+
+    @client.unlock(lock1)
+
+    # edge case with refresh lock in the middle
+    assert_equal true, @client.locked?
+
+    @client.clear
+
+    assert_equal false, @client.locked?
+
+    @client.refresh(lock2)
+
+    assert_equal true, @client.locked?
+
+    @client.unlock(lock2)
+
+    # now finally unlocked
+    assert_equal false, @client.locked?
+  end
+
+  def test_block_refresh
+    success_counter = Queue.new
+    failure_counter = Queue.new
+
+    @client = client(stale_lock_expiration: 0.5)
+
+    t1 = Thread.new do
+      @client.lock do |token|
+        sleep 0.6
+        @client.refresh(token)
+        sleep 1
+        success_counter << 1
+      end
+    end
+
+    t2 = Thread.new do
+      sleep 0.8
+      locked = @client.lock { success_counter << 1 }
+      failure_counter << 1 unless locked
+    end
+
+    [t1, t2].each(&:join)
+
+    assert_equal 1, success_counter.size
+    assert_equal 1, failure_counter.size
+    assert_equal false, @client.locked?
+  end
+
+  def test_refresh_multi
+    success_counter = Queue.new
+    failure_counter = Queue.new
+
+    @client = client(stale_lock_expiration: 0.5, resources: 2)
+
+    t1 = Thread.new do
+      @client.lock do |token|
+        sleep 0.4
+        @client.refresh(token)
+        success_counter << 1
+        sleep 0.5
+      end
+    end
+
+    t2 = Thread.new do
+      sleep 0.55
+      locked = @client.lock do
+        success_counter << 1
+        sleep 0.5
+      end
+
+      failure_counter << 1 unless locked
+    end
+
+    t3 = Thread.new do
+      sleep 0.75
+      locked = @client.lock { success_counter << 1 }
+      failure_counter << 1 unless locked
+    end
+
+    [t1, t2, t3].each(&:join)
+
+    assert_equal 2, success_counter.size
+    assert_equal 1, failure_counter.size
+    assert_equal false, @client.locked?
+  end
+
+  def test_increment_reused_client
+    i = 0
+
+    threads = 2.times.map do
+      Thread.new do
+        @client.lock { i += 1 }
+      end
+    end
+
+    threads.each(&:join)
+
+    assert_equal 2, i
+    assert_equal false, @client.locked?
+  end
+
+  def test_increment_new_client
+    i = 0
+
+    threads = 2.times.map do
+      Thread.new do
+        # note this is the method that generates a *new* client
+        client.lock { i += 1 }
+      end
+    end
+
+    threads.each(&:join)
+
+    assert_equal 2, i
+    assert_equal false, @client.locked?
+  end
+end
+
+class TestBaseClient < Minitest::Test
+  def setup
+    @client = Suo::Client::Base.new(TEST_KEY, client: {})
+  end
+
+  def test_not_implemented
+    assert_raises(NotImplementedError) do
+      @client.send(:get)
+    end
+
+    assert_raises(NotImplementedError) do
+      @client.send(:set, "", "")
+    end
+
+    assert_raises(NotImplementedError) do
+      @client.send(:initial_set)
+    end
+
+    assert_raises(NotImplementedError) do
+      @client.send(:clear)
+    end
+  end
+end
+
+class TestMemcachedClient < Minitest::Test
+  include ClientTests
+
+  def setup
+    @dalli = Dalli::Client.new("127.0.0.1:11211")
+    @client = Suo::Client::Memcached.new(TEST_KEY)
+    teardown
+  end
+
+  def teardown
+    @dalli.delete(TEST_KEY)
+  end
+end
+
+class TestRedisClient < Minitest::Test
+  include ClientTests
+
+  def setup
+    @redis = Redis.new
+    @client = Suo::Client::Redis.new(TEST_KEY)
+    teardown
+  end
+
+  def teardown
+    @redis.del(TEST_KEY)
+  end
+end
+
+class TestLibrary < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::Suo::VERSION
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+if ENV["CODECLIMATE_REPO_TOKEN"]
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+require "suo"
+require "thread"
+require "minitest/autorun"
+require "minitest/benchmark"
+
+ENV["SUO_TEST"] = "true"

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: suo-dependless
+version: !ruby/object:Gem::Version
+  version: 0.3.2
+platform: ruby
+authors:
+- Nick Elser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.30.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.30.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.5.0
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+description: Distributed locks (mutexes & semaphores) using Memcached or Redis.
+email:
+- nick.elser@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/suo.rb
+- lib/suo/client/base.rb
+- lib/suo/client/memcached.rb
+- lib/suo/client/redis.rb
+- lib/suo/errors.rb
+- lib/suo/version.rb
+- suo-dependless.gemspec
+- test/client_test.rb
+- test/test_helper.rb
+homepage: https://github.com/bernstein/suo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.9
+signing_key: 
+specification_version: 4
+summary: Distributed locks (mutexes & semaphores) using Memcached or Redis.
+test_files:
+- test/client_test.rb
+- test/test_helper.rb