redis_lock 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ad868ca731e9080d8c65e079d50f14718f696e7
-  data.tar.gz: 5c6e6dc414ed41926ffd3544db3f4f506971e225
+  metadata.gz: 61c884d3d8d49471ef1e435f294296691d7c093c
+  data.tar.gz: d6de74dedf9bc0b18a4711948dc4a3b029526bfa
 SHA512:
-  metadata.gz: cd7fc6334ce0b05e4cc2d60d3bf275703e3207b84b659e3c55e222e6b1ef9ef6d630e239d5a58f70aa7dcf2d17494318f8e54bffbd6f2a406825cf136e395031
-  data.tar.gz: eaf6171599bc5688c6a00e8bc926b2654f4a52c514753f83eae3cd5a5a370153c660cc2879687064531e47b0c91cb033e930f0ab6fc35a4d0a5ad466301d3086
+  metadata.gz: 1b09609658479ead559fd9e868cfdc3ec472a3284708a880a52a5db57179e48ba1cd04ea3516c4d4ef39fe5de8e404c5154df1ffce6e050f24951a02cbe17f3a
+  data.tar.gz: a8f50a8a1dab96d244ee8a223270d22bfe6d48477bb8f3980f885bc6920b4b0b64b9769706919e0708e0b553fb49f1d4e7166dcf70ab4d750fee8ecfb81233ef

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+vendor

data/Gemfile

@@ -6,3 +6,4 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 gemspec
 
 gem 'dystruct'
+gem 'pry'

data/README.md

@@ -58,6 +58,11 @@ RedisLock.setup do |config|
   # logger
   # default: Logger.new(STDOUT)
   config.logger = Rails.logger
+
+  # Default ttl for all your locks
+  # default: 60
+  #
+  # config.default_ttl = 120
 end
 ```
 
@@ -73,28 +78,37 @@ lock.locked? #=> true
 lock.remove #=> true
 lock.locked? #=> false
 ```
-__as Mutex__
+
+
+__semaphore:__
+No one can perform the same operation while this is running the rest of the processes
+are waiting while the lock is in use, When lock is released another one takes the lock.
+
+args:
+  - key [string]
+  - opts: `{}`
+    * :redis
+    * :ttl, time to leave
+    * :set_opts, check `set` documentation
+    * :wait, time waiting for the next check if the lock is in use
+
 ```ruby
-lock = RedisLock.new('my_key')
-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
+out = RedisLock.semaphore('my_key') do |l|
         sleep 3 # Do something
-        l.unlock! # release the lock
         :hello
       end
 out #=> :hello
-lock.locked? #=> false
+RedisLock.new('my_key').locked? #=> false
 ```
 
-__blocking for a time__
+__if_open:__
 
+**Use case:**
 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|
+RedisLock.if_open("User:1-sales-products", ttl: ttl) do |l|
   # Send Email
   l.set(ttl)
 end
@@ -102,15 +116,16 @@ end
 
 ## Methods:
 
-__set__
+### 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.
+  - __ttl__ | default: 60
+  - __opts__ | default: {}
+    * __value__ (String) - default: time now
+    * __px__  - miliseconds instead of seconds | default: false
+    * __nk__  - Only set the key if it does not already exist. | default: false
+    * __xx__  - Only set the key if it already exist. | default: false
 ```ruby
 lock = RedisLock.new('my_key')
 
@@ -119,7 +134,7 @@ lock.ttl #=> 60
 lock.open? # => false
 ```
 
-_with options_
+__with options:__
 
 ```ruby
 lock = RedisLock.new('my_key')
@@ -131,16 +146,17 @@ 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?
 
-__locked?__
 Returns `true` if lock is set
 
 ```ruby
@@ -152,7 +168,8 @@ lock.locked? # => false
 ```
 _alias method:_ `exists?`
 
-__open?__
+### open?
+
 Returns `true` if NO lock is set
 
 ```ruby
@@ -163,7 +180,8 @@ lock.open? # => false
 ```
 _alias method:_ `unlocked?`
 
-__delete__
+### delete
+
 Removes the key from the Redis store
 
 ```ruby
@@ -175,7 +193,8 @@ lock.locked? # => false
 ```
 _alias methods:_ `unlock!`,`open!`
 
-__value__
+### value
+
 Returns the value stored in redis
 
 ```ruby
@@ -183,7 +202,8 @@ lock = RedisLock.new('my_key')
 lock.set(60, value: 'hi there!')
 lock.value # => 'hi there!'
 ```
-__ttl__
+### ttl
+
 Returns the pending ttl (time to live)
 
 ```ruby

data/lib/redis_lock/configuration.rb

@@ -22,7 +22,15 @@ class RedisLock
     end
 
     def logger
-      @logger ? @logger : Logger.new(STDOUT)
+      @logger || Logger.new(STDOUT)
+    end
+
+    def default_ttl=(val)
+      @default_ttl = val
+    end
+
+    def default_ttl
+      @default_ttl || 60
     end
 
     private

data/lib/redis_lock/version.rb

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

data/lib/redis_lock.rb

@@ -13,10 +13,22 @@ class RedisLock
     yield config
   end
 
+  def self.semaphore(key, args = {}, &block)
+    setup_instance(key, args).semaphore(args, &block)
+  end
+
+  def self.if_open(key, args = {}, &block)
+    setup_instance(key, args).if_open(args, &block)
+  end
+
+  def self.if_locked(key, args = {}, &block)
+    setup_instance(key, args).if_locked(args, &block)
+  end
+
   def config; self.class.config; end
 
   def initialize(key, opts = {})
-    @key = key
+    @key = "REDISLOCK::#{key}"
     @redis = opts[:redis]
   end
 
@@ -39,6 +51,18 @@ class RedisLock
     redis.set(key, value, args.merge(opts)) == "OK" ? true : false
   end
 
+  def semaphore(args = {}, &block)
+    ttl = args[:ttl] || config.default_ttl
+    set_opts = args[:set_opts] || {}
+    while locked?
+      sleep (args[:wait] || 3)
+    end
+    set(ttl, set_opts)
+    out = _perform(&block)
+    unlock!
+    out
+  end
+
   def if_open(args = {}, &block)
     return if locked?
     _perform(&block)
@@ -54,6 +78,7 @@ class RedisLock
     ttl == -2 ? false : true
   end
   alias_method :exists?, :locked?
+  alias_method :in_use?, :locked?
 
   def ttl
     redis.ttl(key)
@@ -77,6 +102,11 @@ class RedisLock
 
   private
 
+  def self.setup_instance(key, args)
+    inst_opts = { redis: args.delete(:redis) }.reject{ |_, v| v.nil? }
+    new(key, inst_opts)
+  end
+
   def _perform(&block)
     yield self
   rescue => e

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_lock
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-12 00:00:00.000000000 Z
+date: 2018-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -117,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.3
+rubygems_version: 2.5.2.2
 signing_key: 
 specification_version: 4
 summary: Lock with redis