global_lock 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69155a838b0da2011d49f045a4c83707291d39e9ca4995d4e42f794513e6712b
-  data.tar.gz: cb8f0baa5d7a03849f6df53cd9da64c3a2e48d6d3937d61d4d29adc81ae89d0e
+  metadata.gz: 97815ec2fc504cc021191f09ae1ae6e375dfff0a94bf8ee6f5d1eed164a246d1
+  data.tar.gz: 3629dda16e66bd051fc0c66f47c4b85f6f22eb4ca728940f9f8cb3f36e17fa7e
 SHA512:
-  metadata.gz: 4fb7d9fcd49c6f93edc58803ef48c7fdcf56cbcbdd4c7b72d0cc53f656e05fd16ddbb2afa217c05737b861d25297029f28d3345c10f8e24d2d8bf65991d28ce5
-  data.tar.gz: 4cd37814c3603c1b65db39a77dabb3089c3ebef9aa36963ffb377b1b9a9fb27349dd719f3f0d118a2038cee64fcc8c56f34334e3cf031d3a42e1e18d29e2d280
+  metadata.gz: 3374a9371f5945b30efc735bd2ef2c75437515d8c967f01bd69cb35b4313c0498735f512fde9dd2885c7748f170c17e4ecb5d0c1c6189327fb6e1177badcfe8f
+  data.tar.gz: f17a19a4d05b744c823c88fe5def7d709b31c8cca57c362a202fde5156da4984482f83d6877a4ebce54c9b3aa67b819b7ea1fee8f62765551c4bf9ca0be0b2ab

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+**/*.swp

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    global_lock (0.0.5)
+      connection_pool
+      redis
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    connection_pool (2.2.3)
+    diff-lcs (1.4.4)
+    mock_redis (0.27.3)
+      ruby2_keywords
+    redis (4.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    ruby2_keywords (0.0.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  global_lock!
+  mock_redis
+  rspec
+
+BUNDLED WITH
+   2.1.4

data/global_lock.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = "global_lock"
+  s.version = "0.0.5"
+  s.summary = "Global Lock"
+  s.description = "Global Lock"
+  s.authors = ["Samuel Ballan"]
+  s.email = ["sgb4622@gmail.com"]
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.license = "MIT"
+
+  s.add_dependency "redis"
+  s.add_dependency "connection_pool"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "mock_redis"
+end

data/lib/global_lock/config.rb

@@ -0,0 +1,32 @@
+class GlobalLock::Config
+  attr_accessor :default_ttl,
+                :default_retry_time,
+                :default_backoff_time,
+                :redis_prefix,
+                :redis_connection,
+                :redis_pool
+
+  def initialize(opts = {})
+    self.default_ttl          = opts[:default_ttl]          || 60 * 60 * 24
+    self.default_retry_time   = opts[:default_retry_time]   || 30
+    self.default_backoff_time = opts[:default_backoff_time] || 0.01
+    self.redis_prefix         = opts[:redis_prefix]         || "GlobalLock/"
+    self.redis_connection     = opts[:redis_connection]     || Redis.new
+    self.redis_pool           = opts[:redis_pool]           || ConnectionPool.new { self.redis_connection }
+  end
+
+  def lock_opts
+    {
+      ttl: default_ttl,
+      retry_time: default_retry_time,
+      backoff_time: default_backoff_time,
+      redis_prefix: redis_prefix,
+      redis_connection: redis_connection,
+      redis_pool: redis_pool
+    }
+  end
+
+  def with_redis(&block)
+    redis_pool.with(&block)
+  end
+end

data/lib/global_lock/errors.rb

@@ -0,0 +1,7 @@
+module GlobalLock
+  module Errors
+    class Base < StandardError; end
+    class FailedToLockError < Base; end
+    class FailedToUnlockError < Base; end
+  end
+end

data/lib/global_lock/lock.rb

@@ -0,0 +1,99 @@
+class GlobalLock::Lock
+  attr_reader :config
+
+  def initialize(opts = {})
+    if opts.is_a?(GlobalLock::Config)
+      @config = opts
+    else
+      @config = GlobalLock::Config.new(opts)
+    end
+  end
+
+  def with_lock(name, existing_key=nil, opts={}, &block)
+    opts = config.lock_opts.merge(opts)
+    raise ArgumentError.new("Block required") unless block_given?
+
+    ret_val = nil
+
+    if !existing_key.nil && correct_key?(name, existing_key)
+      ret_val = block.call(existing_key)
+    elsif !existing_key.nil?
+      raise GlobalLock::Errors::FailedToLockError.new("Used incorrect existing key")
+    else
+      key = lock(name, opts)
+      raise GlobalLock::Errors::FailedToLockError.new("Failed to acquire lock") if (key == false)
+
+      ret_val = block.call(key)
+
+      unlock_success = unlock(name, key)
+      raise GlobalLock::Errors::FailedToUnlockError.new("Failed to unlock") unless unlock_success
+    end
+
+    ret_val
+  end
+
+  def lock(name, opts={})
+    opts = config.lock_opts.merge(opts)
+    ttl, retry_time, backoff_time = opts.values_at(:ttl, :retry_time, :backoff_time)
+
+    key = SecureRandom.uuid
+    success = write_lock(name, key, ex: ttl)
+
+    if success
+      key
+    elsif retry_time > 0
+      sleep backoff_time
+
+      # Note: really, the backoff factor should be multiplied by retry_wait
+
+      lock(
+        name,
+        ttl: ttl,
+        retry_time: retry_time - backoff_time,
+        backoff_time: backoff_time * 2 * rand(0.5..1.5)
+      )
+    else
+      false
+    end
+  end
+
+  def unlock(name, key)
+    if correct_key?(name, key)
+      delete_lock(name)
+    else
+      false
+    end
+  end
+
+  def correct_key?(name, possible_key)
+    return false unless name && possible_key && !name.empty? && !possible_key.empty?
+
+    actual_key = fetch_lock_key(name)
+    possible_key == actual_key
+  end
+
+  protected
+
+  def write_lock(name, key, ex: nil)
+    ex ||= config.default_ttl
+    raise ArgumentError.new("Cannot write_lock with blank name") if name.empty?
+
+    res = config.with_redis do |redis|
+      redis.set(config.redis_prefix + name, key, ex: ex, nx: true)
+    end
+    res == true
+  end
+
+  def fetch_lock_key(name)
+    config.with_redis do |redis|
+      redis.get(config.redis_prefix + name)
+    end
+  end
+
+  def delete_lock(name)
+    res = config.with_redis do |redis|
+      redis.del(config.redis_prefix + name)
+    end
+    res == 1
+  end
+end

data/lib/global_lock/lockable.rb

@@ -0,0 +1,37 @@
+module GlobalLock
+  module Lockable
+    def self.included(other_mod)
+      # This pattern lets us have instance _and_ class methods in this module
+      other_mod.extend ClassMethods
+    end
+
+    def lock_id
+      send(self.class.lock_id_name)
+    end
+
+    def lock(opts={})
+    GlobalLock.singleton.lock(lock_id, opts)
+    end
+
+    def unlock(key)
+      GlobalLock.singleton.unlock(lock_id, key)
+    end
+
+    def with_lock(existing_key=nil, opts={}, &block)
+    GlobalLock.singleton.with_lock(lock_id, existing_key, opts, &block)
+    end
+
+    # This pattern lets us have instance _and_ class methods in this module
+    module ClassMethods
+      def lock_id_name
+        @lock_id_name || :id
+      end
+
+      def set_lock_id_name(lock_id_name)
+        raise "Lock name must be symbol" unless lock_id_name.is_a? Symbol
+
+        @lock_id_name = lock_id_name
+      end
+    end
+  end
+end

data/spec/global_lock/config_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe GlobalLock::Config do
+
+  context "Basics" do
+    it "can be created with no arguments" do
+      config = GlobalLock::Config.new
+      expect(config).to be
+    end
+
+    it "has correct defaults" do
+      config = GlobalLock::Config.new
+
+      expect(config.default_ttl).to          eql(60 * 60 * 24)
+      expect(config.default_retry_time).to   eql(30)
+      expect(config.default_backoff_time).to eql(0.01)
+      expect(config.redis_prefix).to         eql("GlobalLock/")
+    end
+
+    it "can be configured" do
+      config = GlobalLock::Config.new(
+        default_ttl: 1,
+        default_retry_time: 2,
+        default_backoff_time: 3,
+        redis_prefix: "4"
+      )
+
+      expect(config.default_ttl).to eql(1)
+      expect(config.default_retry_time).to eql(2)
+      expect(config.default_backoff_time).to eql(3)
+      expect(config.redis_prefix).to eql("4")
+    end
+  end
+end

data/spec/global_lock/lock_spec.rb

@@ -0,0 +1,97 @@
+require "spec_helper"
+
+describe GlobalLock::Lock do
+  before do
+    @mock_redis = MockRedis.new
+    @gl = GlobalLock::Lock.new redis_connection: @mock_redis
+  end
+
+  let(:test_lock_name) { 'test_lock_name' }
+  let(:redis_test_lock_name) { @gl.config.redis_prefix + test_lock_name }
+
+  after(:each) do
+    @mock_redis.del(redis_test_lock_name)
+  end
+
+  describe "lock" do
+    context "is available" do
+      it "gets the lock" do
+        key = @gl.lock(test_lock_name)
+        found_key = @mock_redis.get(redis_test_lock_name)
+        expect(found_key).to eql(key)
+      end
+    end
+
+    context "is not available" do
+      it "does not get the lock" do
+        real_key = @gl.lock(test_lock_name, retry_time: 0)
+        false_key = @gl.lock(test_lock_name, retry_time: 0)
+
+        expect(false_key).to eql(false)
+      end
+    end
+  end
+
+  describe "unlock" do
+    it "can unlock existing lock" do
+      key = 'test_lock_key'
+      @mock_redis.set(redis_test_lock_name, key)
+      found_key = @mock_redis.get(redis_test_lock_name)
+      expect(found_key).to eql(key)
+
+      @gl.unlock(test_lock_name, key)
+
+      found_key = @mock_redis.get(redis_test_lock_name)
+      expect(found_key).to be_nil
+    end
+
+    it "returns false with wrong key" do
+      correct_key = 'test_lock_key'
+      incorrect_key = 'bad_key'
+      @mock_redis.set(redis_test_lock_name, correct_key)
+
+      success = @gl.unlock(test_lock_name, incorrect_key)
+
+      expect(success).to be_falsey
+    end
+  end
+
+  context "private methods" do
+    describe "write_lock" do
+      it "writes the correct key" do
+        key = 'test_lock_key'
+        @gl.send(:write_lock, test_lock_name, key)
+        found_key = @mock_redis.get(redis_test_lock_name)
+        expect(found_key).to eql(key)
+      end
+    end
+
+    describe "fetch_lock_key" do
+      it "fetches the correct key" do
+        key = 'test_lock_key'
+        @mock_redis.set(redis_test_lock_name, key)
+        found_key = @gl.send(:fetch_lock_key, test_lock_name)
+        expect(key).to eql(found_key)
+      end
+    end
+
+    describe "delete_lock" do
+      it "deletes correct lock" do
+        other_test_lock_name = 'other_text_lock_name'
+        other_redis_test_lock_name = @gl.config.redis_prefix + other_test_lock_name
+        other_key = 'other_test_lock_key'
+        @mock_redis.set(other_redis_test_lock_name, other_key)
+
+        key = 'test_lock_key'
+        @mock_redis.set(redis_test_lock_name, key)
+        @gl.send(:delete_lock, test_lock_name)
+
+        found_key = @mock_redis.get(redis_test_lock_name)
+        other_found_key = @mock_redis.get(other_redis_test_lock_name)
+
+        expect(found_key).to be_nil
+        expect(other_found_key).to eql(other_key)
+      end
+    end
+  end
+end

data/spec/global_lock/lockable_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe GlobalLock::Lockable do
+  before do
+    @mock_redis = MockRedis.new
+    GlobalLock.config do |c|
+      c.redis_connection     = @mock_redis
+      c.default_ttl          = 60 * 5
+      c.default_retry_time   = 1
+      c.default_backoff_time = 1
+    end
+  end
+
+  let(:test_lock_name) { 'test_lock_name' }
+  let(:redis_test_lock_name) { GlobalLock.config.redis_prefix + test_lock_name }
+
+  after(:each) do
+    @mock_redis.flushdb
+  end
+
+  class MockLockable
+    include GlobalLock::Lockable
+    set_lock_id_name :id
+
+    def id
+      @id ||= SecureRandom.uuid
+    end
+  end
+
+  context 'included' do
+    let(:lockable) { MockLockable.new }
+    describe 'lock' do
+      it 'returns the lock key' do
+        key = lockable.lock
+        expected_key = @mock_redis.get(GlobalLock.config.redis_prefix + lockable.id)
+
+        expect(key).to eql(expected_key)
+      end
+
+      it 'returns false if already locked' do
+        successful_key = lockable.lock
+        failed_key = lockable.lock
+
+        expect(successful_key).to be_a String
+        expect(failed_key).to eql(false)
+      end
+    end
+  end
+
+
+end

data/spec/global_lock_spec.rb

@@ -0,0 +1 @@
+require "spec_helper"

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'mock_redis'
+require 'global_lock.rb'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: global_lock
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Samuel Ballan
@@ -73,7 +73,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- global_lock.gemspec
 - lib/global_lock.rb
+- lib/global_lock/config.rb
+- lib/global_lock/errors.rb
+- lib/global_lock/lock.rb
+- lib/global_lock/lockable.rb
+- spec/global_lock/config_spec.rb
+- spec/global_lock/lock_spec.rb
+- spec/global_lock/lockable_spec.rb
+- spec/global_lock_spec.rb
+- spec/spec_helper.rb
 homepage:
 licenses:
 - MIT
@@ -97,4 +111,9 @@ rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: Global Lock
-test_files: []
+test_files:
+- spec/global_lock/config_spec.rb
+- spec/global_lock/lock_spec.rb
+- spec/global_lock/lockable_spec.rb
+- spec/global_lock_spec.rb
+- spec/spec_helper.rb