suo 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a30ddf4504c61a3c6e3896fea1300c8100140902
-  data.tar.gz: ec8b97cf374d959037c8825e9f0a6131f487dcff
+  metadata.gz: 6334c57e0648ae8fefdeb1113664c3e6631dd03c
+  data.tar.gz: 0f35accaea812d463d911b1602a30372952ca19b
 SHA512:
-  metadata.gz: e630516db130906d81fc7dafcb8c8532711710cfe6dbcd2932d2245a8294af716ac65b4d2551876acac7815a8d08593009489329c1f305f8f4927e64cb19b2e0
-  data.tar.gz: 135a570b6781da6ffb9232845a6ef7a9c096edb63025588b77173b6b93f69e63ceeb8de41a8818aa2d4cbf3c9d15b4d7ed2f04ff6bf2973c3cea47d74bcd77f7
+  metadata.gz: 51081aad925fa7032551ff81be52f724ed8fcd9592dfbfb7aea70d1a837597bdeabdcbe0bb9946629cbc2f853a81d1e8b501ec2b1d1ba8ba3c57a4ff6d43a77a
+  data.tar.gz: cce84bf639f8303f241a3c901d92991ae5e72b95c918601db06b75ca98cef250c85d3a00c0a2e3412ce539f2eb6acfedfeda1297ae1fbf033844477bc26b79fa

data/CHANGELOG.md

@@ -1,8 +1,12 @@
+## 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 semaphore serialization.
 
-
 ## 0.1.0
 
 - First release.

data/README.md

@@ -1,4 +1,4 @@
-# Suo [![Build Status](https://travis-ci.org/nickelser/suo.png?branch=master)](https://travis-ci.org/nickelser/suo)
+# Suo [![Build Status](https://travis-ci.org/nickelser/suo.svg?branch=master)](https://travis-ci.org/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.
 
@@ -42,7 +42,6 @@ end
 ## TODO
  - better stale key handling (refresh blocks)
  - more race condition tests
- - refactor clients to re-use more code
 
 ## History
 

data/lib/suo/client/base.rb

@@ -2,13 +2,13 @@ module Suo
   module Client
     class Base
       DEFAULT_OPTIONS = {
-        retry_count: 3,
+        retry_timeout: 0.1,
         retry_delay: 0.01,
         stale_lock_expiration: 3600
       }.freeze
 
       def initialize(options = {})
-        @options = self.class.merge_defaults(options).merge(_initialized: true)
+        @options = self.class.merge_defaults(options)
       end
 
       def lock(key, resources = 1, options = {})
@@ -33,32 +33,86 @@ module Suo
       end
 
       class << self
-        def lock(key, resources = 1, options = {}) # rubocop:disable Lint/UnusedMethodArgument
-          fail NotImplementedError
+        def lock(key, resources = 1, options = {})
+          options = merge_defaults(options)
+          acquisition_token = nil
+          token = SecureRandom.base64(16)
+
+          retry_with_timeout(key, options) do
+            val, cas = get(key, options)
+
+            if val.nil?
+              set_initial(key, options)
+              next
+            end
+
+            locks = deserialize_and_clear_locks(val, options)
+
+            if locks.size < resources
+              add_lock(locks, token)
+
+              newval = serialize_locks(locks)
+
+              if set(key, newval, cas, options)
+                acquisition_token = token
+                break
+              end
+            end
+          end
+
+          acquisition_token
         end
 
         def locked?(key, resources = 1, options = {})
-          options = merge_defaults(options)
-          client = options[:client]
-          locks = deserialize_locks(client.get(key))
-
-          locks.size >= resources
+          locks(key, options).size >= resources
         end
 
         def locks(key, options)
           options = merge_defaults(options)
-          client = options[:client]
-          locks = deserialize_locks(client.get(key))
+          val, _ = get(key, options)
+          locks = deserialize_locks(val)
 
-          locks.size
+          locks
         end
 
-        def refresh(key, acquisition_token, options = {}) # rubocop:disable Lint/UnusedMethodArgument
-          fail NotImplementedError
+        def refresh(key, acquisition_token, options = {})
+          options = merge_defaults(options)
+
+          retry_with_timeout(key, options) do
+            val, cas = get(key, options)
+
+            if val.nil?
+              set_initial(key, options)
+              next
+            end
+
+            locks = deserialize_and_clear_locks(val, options)
+
+            refresh_lock(locks, acquisition_token)
+
+            break if set(key, serialize_locks(locks), cas, options)
+          end
         end
 
-        def unlock(key, acquisition_token, options = {}) # rubocop:disable Lint/UnusedMethodArgument
-          fail NotImplementedError
+        def unlock(key, acquisition_token, options = {})
+          options = merge_defaults(options)
+
+          return unless acquisition_token
+
+          retry_with_timeout(key, options) do
+            val, cas = get(key, options)
+
+            break if val.nil?
+
+            locks = deserialize_and_clear_locks(val, options)
+
+            acquisition_lock = remove_lock(locks, acquisition_token)
+
+            break unless acquisition_lock
+            break if set(key, serialize_locks(locks), cas, options)
+          end
+        rescue FailedToAcquireLock => _ # rubocop:disable Lint/HandleExceptions
+          # ignore - assume success due to optimistic locking
         end
 
         def clear(key, options = {}) # rubocop:disable Lint/UnusedMethodArgument
@@ -66,27 +120,64 @@ module Suo
         end
 
         def merge_defaults(options = {})
-          unless options[:_initialized]
-            options = self::DEFAULT_OPTIONS.merge(options)
+          options = self::DEFAULT_OPTIONS.merge(options)
 
-            fail "Client required" unless options[:client]
-          end
+          fail "Client required" unless options[:client]
 
-          if options[:retry_timeout]
-            options[:retry_count] = (options[:retry_timeout] / options[:retry_delay].to_f).floor
-          end
+          options[:retry_count] = (options[:retry_timeout] / options[:retry_delay].to_f).ceil
 
           options
         end
 
         private
 
+        def get(key, options) # rubocop:disable Lint/UnusedMethodArgument
+          fail NotImplementedError
+        end
+
+        def set(key, newval, oldval, options) # rubocop:disable Lint/UnusedMethodArgument
+          fail NotImplementedError
+        end
+
+        def set_initial(key, options) # rubocop:disable Lint/UnusedMethodArgument
+          fail NotImplementedError
+        end
+
+        def synchronize(key, options)
+          yield(key, options)
+        end
+
+        def retry_with_timeout(key, options)
+          start = Time.now.to_f
+
+          options[:retry_count].times do
+            if options[:retry_timeout]
+              now = Time.now.to_f
+              break if now - start > options[:retry_timeout]
+            end
+
+            synchronize(key, options) do
+              yield
+            end
+
+            sleep(rand(options[:retry_delay] * 1000).to_f / 1000)
+          end
+        rescue => _
+          raise FailedToAcquireLock
+        end
+
         def serialize_locks(locks)
           MessagePack.pack(locks.map { |time, token| [time.to_f, token] })
         end
 
+        def deserialize_and_clear_locks(val, options)
+          clear_expired_locks(deserialize_locks(val), options)
+        end
+
         def deserialize_locks(val)
-          MessagePack.unpack(val).map do |time, token|
+          unpacked = (val.nil? || val == "") ? [] : MessagePack.unpack(val)
+
+          unpacked.map do |time, token|
             [Time.at(time), token]
           end
         rescue EOFError => _

data/lib/suo/client/memcached.rb

@@ -7,129 +7,23 @@ module Suo
       end
 
       class << self
-        def lock(key, resources = 1, options = {})
+        def clear(key, options = {})
           options = merge_defaults(options)
-          acquisition_token = nil
-          token = SecureRandom.base64(16)
-          client = options[:client]
-
-          begin
-            start = Time.now.to_f
-
-            options[:retry_count].times do
-              if options[:retry_timeout]
-                now = Time.now.to_f
-                break if now - start > options[:retry_timeout]
-              end
-
-              val, cas = client.get_cas(key)
-
-              # no key has been set yet; we could simply set it, but would lead to race conditions on the initial setting
-              if val.nil?
-                client.set(key, "")
-                next
-              end
-
-              locks = clear_expired_locks(deserialize_locks(val.to_s), options)
-
-              if locks.size < resources
-                add_lock(locks, token)
-
-                newval = serialize_locks(locks)
-
-                if client.set_cas(key, newval, cas)
-                  acquisition_token = token
-                  break
-                end
-              end
-
-              sleep(rand(options[:retry_delay] * 1000).to_f / 1000)
-            end
-          rescue => _
-            raise FailedToAcquireLock
-          end
-
-          acquisition_token
+          options[:client].delete(key)
         end
 
-        def refresh(key, acquisition_token, options = {})
-          options = merge_defaults(options)
-          client = options[:client]
-
-          begin
-            start = Time.now.to_f
-
-            options[:retry_count].times do
-              if options[:retry_timeout]
-                now = Time.now.to_f
-                break if now - start > options[:retry_timeout]
-              end
-
-              val, cas = client.get_cas(key)
-
-              # much like with initial set - ensure the key is here
-              if val.nil?
-                client.set(key, "")
-                next
-              end
-
-              locks = clear_expired_locks(deserialize_locks(val), options)
-
-              refresh_lock(locks, acquisition_token)
+        private
 
-              newval = serialize_locks(locks)
-
-              break if client.set_cas(key, newval, cas)
-
-              sleep(rand(options[:retry_delay] * 1000).to_f / 1000)
-            end
-          rescue => _
-            raise FailedToAcquireLock
-          end
+        def get(key, options)
+          options[:client].get_cas(key)
         end
 
-        def unlock(key, acquisition_token, options = {})
-          options = merge_defaults(options)
-          client = options[:client]
-
-          return unless acquisition_token
-
-          begin
-            start = Time.now.to_f
-
-            options[:retry_count].times do
-              if options[:retry_timeout]
-                now = Time.now.to_f
-                break if now - start > options[:retry_timeout]
-              end
-
-              val, cas = client.get_cas(key)
-
-              break if val.nil? # lock has expired totally
-
-              locks = clear_expired_locks(deserialize_locks(val), options)
-
-              acquisition_lock = remove_lock(locks, acquisition_token)
-
-              break unless acquisition_lock
-
-              newval = serialize_locks(locks)
-
-              break if client.set_cas(key, newval, cas)
-
-              # another client cleared a token in the interim - try again!
-
-              sleep(rand(options[:retry_delay] * 1000).to_f / 1000)
-            end
-          rescue => boom # rubocop:disable Lint/HandleExceptions
-            # since it's optimistic locking - fine if we are unable to release
-            raise boom if ENV["SUO_TEST"]
-          end
+        def set(key, newval, cas, options)
+          options[:client].set_cas(key, newval, cas)
         end
 
-        def clear(key, options = {})
-          options = merge_defaults(options)
-          options[:client].delete(key)
+        def set_initial(key, options)
+          options[:client].set(key, "")
         end
       end
     end

data/lib/suo/client/redis.rb

@@ -7,158 +7,35 @@ module Suo
       end
 
       class << self
-        def lock(key, resources = 1, options = {})
+        def clear(key, options = {})
           options = merge_defaults(options)
-          acquisition_token = nil
-          token = SecureRandom.base64(16)
-          client = options[:client]
-
-          begin
-            start = Time.now.to_f
-
-            options[:retry_count].times do
-              if options[:retry_timeout]
-                now = Time.now.to_f
-                break if now - start > options[:retry_timeout]
-              end
-
-              client.watch(key) do
-                begin
-                  val = client.get(key)
-
-                  locks = clear_expired_locks(deserialize_locks(val.to_s), options)
-
-                  if locks.size < resources
-                    add_lock(locks, token)
-
-                    newval = serialize_locks(locks)
-
-                    ret = client.multi do |multi|
-                      multi.set(key, newval)
-                    end
-
-                    acquisition_token = token if ret[0] == "OK"
-                  end
-                ensure
-                  client.unwatch
-                end
-              end
-
-              break if acquisition_token
-
-              sleep(rand(options[:retry_delay] * 1000).to_f / 1000)
-            end
-          rescue => _
-            raise Suo::Client::FailedToAcquireLock
-          end
-
-          acquisition_token
+          options[:client].del(key)
         end
 
-        def refresh(key, acquisition_token, options = {})
-          options = merge_defaults(options)
-          client = options[:client]
-          refreshed = false
-
-          begin
-            start = Time.now.to_f
-
-            options[:retry_count].times do
-              if options[:retry_timeout]
-                now = Time.now.to_f
-                break if now - start > options[:retry_timeout]
-              end
-
-              client.watch(key) do
-                begin
-                  val = client.get(key)
-
-                  locks = clear_expired_locks(deserialize_locks(val), options)
-
-                  refresh_lock(locks, acquisition_token)
-
-                  newval = serialize_locks(locks)
-
-                  ret = client.multi do |multi|
-                    multi.set(key, newval)
-                  end
+        private
 
-                  refreshed = ret[0] == "OK"
-                ensure
-                  client.unwatch
-                end
-              end
-
-              break if refreshed
-
-              sleep(rand(options[:retry_delay] * 1000).to_f / 1000)
-            end
-          rescue => _
-            raise Suo::Client::FailedToAcquireLock
-          end
+        def get(key, options)
+          [options[:client].get(key), nil]
         end
 
-        def unlock(key, acquisition_token, options = {})
-          options = merge_defaults(options)
-          client = options[:client]
-
-          return unless acquisition_token
-
-          begin
-            start = Time.now.to_f
-
-            options[:retry_count].times do
-              cleared = false
-
-              if options[:retry_timeout]
-                now = Time.now.to_f
-                break if now - start > options[:retry_timeout]
-              end
-
-              client.watch(key) do
-                begin
-                  val = client.get(key)
-
-                  if val.nil?
-                    cleared = true
-                    break
-                  end
-
-                  locks = clear_expired_locks(deserialize_locks(val), options)
-
-                  acquisition_lock = remove_lock(locks, acquisition_token)
-
-                  unless acquisition_lock
-                    # token was already cleared
-                    cleared = true
-                    break
-                  end
-
-                  newval = serialize_locks(locks)
-
-                  ret = client.multi do |multi|
-                    multi.set(key, newval)
-                  end
-
-                  cleared = ret[0] == "OK"
-                ensure
-                  client.unwatch
-                end
-              end
+        def set(key, newval, _, options)
+          ret = options[:client].multi do |multi|
+            multi.set(key, newval)
+          end
 
-              break if cleared
+          ret[0] == "OK"
+        end
 
-              sleep(rand(options[:retry_delay] * 1000).to_f / 1000)
-            end
-          rescue => boom # rubocop:disable Lint/HandleExceptions
-            # since it's optimistic locking - fine if we are unable to release
-            raise boom if ENV["SUO_TEST"]
+        def synchronize(key, options)
+          options[:client].watch(key) do
+            yield
           end
+        ensure
+          options[:client].unwatch
         end
 
-        def clear(key, options = {})
-          options = merge_defaults(options)
-          options[:client].del(key)
+        def set_initial(key, options)
+          options[:client].set(key, "")
         end
       end
     end

data/lib/suo/version.rb

@@ -1,3 +1,3 @@
 module Suo
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/test/client_test.rb

@@ -24,6 +24,7 @@ module ClientTests
     @klass.unlock(TEST_KEY, lock1, client: @klass_client)
 
     locked = @klass.locked?(TEST_KEY, 1, client: @klass_client)
+
     assert_equal false, locked
   end
 
@@ -74,8 +75,8 @@ module ClientTests
 
     100.times.map do |i|
       Thread.new do
-        success = @client.lock(TEST_KEY, 50, retry_timeout: 0.9) do
-          sleep(1)
+        success = @client.lock(TEST_KEY, 50, retry_timeout: 0.5) do
+          sleep(2)
           success_counter << i
         end
 
@@ -94,7 +95,7 @@ module ClientTests
     100.times.map do |i|
       Thread.new do
         success = @client.lock(TEST_KEY, 50, retry_timeout: 2) do
-          sleep(1)
+          sleep(0.5)
           success_counter << i
         end
 
@@ -114,7 +115,7 @@ class TestBaseClient < Minitest::Test
 
   def test_not_implemented
     assert_raises(NotImplementedError) do
-      @klass.lock(TEST_KEY, 1)
+      @klass.send(:get, TEST_KEY, {})
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: suo
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Nick Elser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-12 00:00:00.000000000 Z
+date: 2015-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dalli