redis_lock 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee826bd92ec9c79acb13dd5abd4c25cae2b58740
-  data.tar.gz: 8111863df02cc6c004e9ae65cbdfa5106fc7eb89
+  metadata.gz: 3ad868ca731e9080d8c65e079d50f14718f696e7
+  data.tar.gz: 5c6e6dc414ed41926ffd3544db3f4f506971e225
 SHA512:
-  metadata.gz: 658f04d297764af0e0fe29739972eacd3aebeeb43334c59d51fe070ca86e7455afa75e6c4b3ff6fe1a6b44d7327cf00ee39443295ef793a7080756dfa97d0697
-  data.tar.gz: e7b3e9954828b0fc0d53c15b35476561ecfbf52d201e7977baeeadb4c66861bf677f495bc5334964d34a089eb148470020b42b0571953886b4280447ec35478f
+  metadata.gz: cd7fc6334ce0b05e4cc2d60d3bf275703e3207b84b659e3c55e222e6b1ef9ef6d630e239d5a58f70aa7dcf2d17494318f8e54bffbd6f2a406825cf136e395031
+  data.tar.gz: eaf6171599bc5688c6a00e8bc926b2654f4a52c514753f83eae3cd5a5a370153c660cc2879687064531e47b0c91cb033e930f0ab6fc35a4d0a5ad466301d3086

data/Gemfile

@@ -5,4 +5,4 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in redis_lock.gemspec
 gemspec
 
-gem 'contextuable'
+gem 'dystruct'

data/README.md

@@ -1,7 +1,8 @@
 # RedisLock
+**use cases:**
 
-Do not allow anyone to perfor de same operation while this is running.
-Do not perform this operation unless the previous was executed in more than 5 minutes ago.
+- Do not allow anyone to perform de same operation while this is running.
+- Do not perform this operation unless the previous was executed in more than 5 minutes ago.
 
 ## Installation
 
@@ -21,11 +22,41 @@ Or install it yourself as:
 
 ## Setup
 
+This setup it's optional in any instance of `RedisLock` you can provide an optional
+argument `:redis`.
+But if you do not want to provide it in all the instances is a good shortcut to
+set it here.
+
 ```ruby
 RedisLock.setup do |config|
+  # redis
+  # Accepts `block` (or something responding to `#call`) or `Hash`
+  #
+  # In test configuration like your `spec_helper`
+  # recommend `mock_redis` gem
+  # example:
+  #    config.redis = -> { MockRedis.new }
+  #
+  # When using Sidekiq
+  # example:    
+  #    config.redis = -> { Sidekiq.redis{ |r| r } }
+  #
+  # In `Rails`
+  # example:
+  #     config.redis = -> do
+  #       if Rails.env.test?
+  #         MockRedis.new
+  #       elsif Rails.env.development?
+  #         { host: '127.0.0.1', port: 6379 }
+  #       else
+  #         Sidekiq.redis{ |r| r }
+  #       end
+  #     end
   config.redis = { host: '127.0.0.1'
                    port: 6379
                    db: 2 }
+  # logger
+  # default: Logger.new(STDOUT)
   config.logger = Rails.logger
 end
 ```
@@ -42,20 +73,135 @@ lock.locked? #=> true
 lock.remove #=> true
 lock.locked? #=> false
 ```
-
+__as Mutex__
 ```ruby
 lock = RedisLock.new('my_key')
-out = subject.perform do
-        #no one can perform the same operation while this is running
-        {}.tap do |t|
-          t[:locked?] = subject.locked?
-        end
+out = lock.if_open do |l|
+        # no one can perform the same operation while this is running
+        l.set(30) # place the lock so no one else can perform this tasks
+        sleep 3 # Do something
+        l.unlock! # release the lock
+        :hello
       end
-out[:locked?] #=> true
-# once the block has finished releases the lock
+out #=> :hello
 lock.locked? #=> false
 ```
 
+__blocking for a time__
+
+Send email to user. The User should receive only 1 email per day
+
+```ruby
+ttl = (24 * 3600) # one day
+lock = RedisLock.new("User:1-sales-products")
+lock.if_open do |l|
+  # Send Email
+  l.set(ttl)
+end
+```
+
+## Methods:
+
+__set__
+Will store the key to redis with a ttl (time to live).
+args:
+  - ttl # default: 60
+  - opts # default: {}
+    * value (String) - default: time now
+    * px (true) - miliseconds instead of seconds default: false
+    * nk (true) - Only set the key if it does not already exist.
+    * xx (true) - Only set the key if it already exist.
+```ruby
+lock = RedisLock.new('my_key')
+
+lock.set(60)
+lock.ttl #=> 60
+lock.open? # => false
+```
+
+_with options_
+
+```ruby
+lock = RedisLock.new('my_key')
+
+lock.set(60, nx: true) # only if the key does not exists
+# => true (key has been stored)
+lock.ttl #=> 60
+lock.open? # => false
+```
+
+Redis documentation: https://redis.io/commands/set
+
+Set key to hold the string value. If key already holds a value, it is overwritten, regardless of its type. Any previous time to live associated with the key is discarded on successful SET operation.
+
+EX seconds -- Set the specified expire time, in seconds.
+PX milliseconds -- Set the specified expire time, in milliseconds.
+NX -- Only set the key if it does not already exist.
+XX -- Only set the key if it already exist.
+
+
+__locked?__
+Returns `true` if lock is set
+
+```ruby
+lock = RedisLock.new('my_key')
+lock.set(60) # => true (key has been stored)
+lock.locked? # => true
+lock.remove
+lock.locked? # => false
+```
+_alias method:_ `exists?`
+
+__open?__
+Returns `true` if NO lock is set
+
+```ruby
+lock = RedisLock.new('my_key')
+lock.open? # => true
+lock.set(60) # => true (key has been stored)
+lock.open? # => false
+```
+_alias method:_ `unlocked?`
+
+__delete__
+Removes the key from the Redis store
+
+```ruby
+lock = RedisLock.new('my_key')
+lock.set(60) # => true (key has been stored)
+lock.locked? # => true
+lock.delete
+lock.locked? # => false
+```
+_alias methods:_ `unlock!`,`open!`
+
+__value__
+Returns the value stored in redis
+
+```ruby
+lock = RedisLock.new('my_key')
+lock.set(60, value: 'hi there!')
+lock.value # => 'hi there!'
+```
+__ttl__
+Returns the pending ttl (time to live)
+
+```ruby
+lock = RedisLock.new('my_key')
+lock.set(60)
+lock.ttl # => 60
+sleep 10
+lock.ttl # => 50
+```
+
+__having already a connection:__ _example: Sidekiq_
+
+```ruby
+Sidekiq.redis do |connection|
+  lock = RedisLock.new('my_key', redis: connection)
+  # do something
+end
+```
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/redis_lock/configuration.rb

@@ -0,0 +1,34 @@
+require 'logger'
+class RedisLock
+  class Configuration
+    class RedisNotSet < StandardError; end
+    def redis=(hash = {})
+      @redis = hash
+    end
+
+    def redis
+      fail RedisNotSet, "[#{self.class}] redis connection setup is not set" unless @redis
+      if @redis.respond_to?(:call)
+        return @redis.call
+      else
+        self.redis_instance = @redis
+        @redis_instance
+      end
+    end
+
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logger
+      @logger ? @logger : Logger.new(STDOUT)
+    end
+
+    private
+
+    def redis_instance=(args)
+      @redis_instance ||= Redis.new(args)
+    end
+  end
+end

data/lib/redis_lock/version.rb

@@ -1,3 +1,3 @@
 class RedisLock
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/redis_lock.rb

@@ -1,12 +1,12 @@
 require 'redis'
 require "redis_lock/version"
-require "redis_lock/config"
+require "redis_lock/configuration"
 
 class RedisLock
   attr_reader :key
 
   def self.config
-    @config ||= Config.new
+    @config ||= Configuration.new
   end
 
   def self.setup
@@ -21,46 +21,67 @@ class RedisLock
   end
 
   def redis
-    @redis ||= Redis.new(config.redis)
+    @redis ||= config.redis
   end
 
-  def set(expiration_time = 600)
-    redis.set(
-      key,
-      Time.now.strftime('%FT%T'),
-      ex: expiration_time, # expires in X seconds
-      nx: true # only if it does not exists
-    )
+  # Redis SET options:
+  # - EX seconds -- Set the specified expire time, in seconds.
+  # - PX milliseconds -- Set the specified expire time, in milliseconds.
+  # - NX -- Only set the key if it does not already exist.
+  # - XX -- Only set the key if it already exist.
+  def set(expiration_time = 60, opts = {})
+    value = opts.delete(:value) || Time.now.strftime('%FT%T')
+    args = if opts[:px]
+             { px: expiration_time }
+           else
+             { ex: expiration_time }
+           end
+    redis.set(key, value, args.merge(opts)) == "OK" ? true : false
   end
 
-  def perform(args = {}, &block)
+  def if_open(args = {}, &block)
     return if locked?
-    expiration = args[:expiration] || args[:ex] || 600
-    set(expiration)
-    # If error occurs, we remove the lock
-    out = _perform(&block)
-    remove
-    out
+    _perform(&block)
   end
+  alias_method :perform, :if_open
 
-
+  def if_locked(args = {}, &block)
+    return if open?
+    _perform(&block)
+  end
 
   def locked?
-    redis.ttl(key) == -2 ? false : true
+    ttl == -2 ? false : true
   end
   alias_method :exists?, :locked?
 
-  def remove
+  def ttl
+    redis.ttl(key)
+  end
+
+  def open?
+    !locked?
+  end
+  alias_method :unlocked?, :open?
+
+  def delete
     redis.del(key) == 1 ? true : false
   end
+  alias_method :unlock!, :delete
+  alias_method :open!, :delete
+  alias_method :remove, :delete
+
+  def value
+    redis.get(key)
+  end
 
   private
 
   def _perform(&block)
     yield self
   rescue => e
-    config.logger.error "[RedisLock] key: `#{key}` error:"
+    config.logger.error "[#{self.class}] key: `#{key}` error:"
     config.logger.error e
-    false
+    raise e
   end
 end

data/redis_lock.gemspec

@@ -23,5 +23,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.15"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency "mock_redis", "~> 0.17"
   spec.add_dependency "redis", "~> 3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_lock
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-29 00:00:00.000000000 Z
+date: 2017-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +95,7 @@ files:
 - bin/console
 - bin/setup
 - lib/redis_lock.rb
-- lib/redis_lock/config.rb
+- lib/redis_lock/configuration.rb
 - lib/redis_lock/version.rb
 - redis_lock.gemspec
 homepage: https://github.com/arturictus/redis_lock.git
@@ -103,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: Lock with redis

data/lib/redis_lock/config.rb

@@ -1,20 +0,0 @@
-class RedisLock
-  class Config
-    def redis=(hash = {})
-      @redis = hash
-    end
-
-    def redis
-      fail "[RedisLock::Config] redis connection setup is not set" unless @redis
-      @redis
-    end
-
-    def logger=(logger)
-      @logger = logger
-    end
-
-    def logger
-      @logger ? @logger : Logger.new(STDOUT)
-    end
-  end
-end