Class: Redis::Lock

Inherits:
BaseObject show all
Defined in:
lib/redis/lock.rb

Overview

Class representing a lock. This functions like a proxy class, in that you can say @object.lock_name { block } to use the lock and also directly, but it is better to use the lock :foo class method in your class to define a lock.

Defined Under Namespace

Classes: LockTimeout

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from BaseObject

#allow_expiration, #as_json, #redis, #set_expiration, #to_hash, #to_json

Constructor Details

#initialize(key, *args) ⇒ Lock

Returns a new instance of Lock.



15
16
17
18
19
20
 
# File 'lib/redis/lock.rb', line 15

def initialize(key, *args)
  super(key, *args)
  @options[:timeout] ||= 5
  @options[:init] = false if @options[:init].nil? # default :init to false
  redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
end

Instance Attribute Details

#key ⇒ Object (readonly)

Returns the value of attribute key.



14
15
16
 
# File 'lib/redis/lock.rb', line 14

def key
  @key
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



14
15
16
 
# File 'lib/redis/lock.rb', line 14

def options
  @options
end

Instance Method Details

#clear ⇒ Object Also known as: delete

Clear the lock. Should only be needed if there’s a server crash or some other event that gets locks in a stuck state.



24
25
26
 
# File 'lib/redis/lock.rb', line 24

def clear
  redis.del(key)
end

#generate_expiration ⇒ Object

Return expiration in milliseconds



78
79
80
 
# File 'lib/redis/lock.rb', line 78

def generate_expiration
  ((@options[:expiration].nil? ? 1 : @options[:expiration].to_f) * 1000).to_i
end

#lock ⇒ Object

Get the lock and execute the code block. Any other code that needs the lock (on any server) will spin waiting for the lock up to the :timeout that was specified when the lock was defined.

Raises:

  • (ArgumentError) 


36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/redis/lock.rb', line 36

def lock
  raise ArgumentError, 'Block not given' unless block_given?
  expiration_ms = generate_expiration
  expiration_s  = expiration_ms / 1000.0
  end_time = nil
  try_until_timeout do
    end_time = Time.now.to_i + expiration_s
    # Set a NX record and use the Redis expiration mechanism.
    # Empty value because the presence of it is enough to lock
    # `px` only except an Integer in millisecond
    break if redis.set(key, nil, px: expiration_ms, nx: true)

    # Backward compatibility code
    # TODO: remove at the next major release for performance
    unless @options[:expiration].nil?
      old_expiration = redis.get(key).to_f

      # Check it was not an empty string with `zero?` and
      # the expiration time is passed.
      if !old_expiration.zero? && old_expiration < Time.now.to_f
        expiration_ms = generate_expiration
        expiration_s  = expiration_ms / 1000.0
        end_time = Time.now.to_i + expiration_s
        break if redis.set(key, nil, px: expiration_ms)
      end
    end
  end
  begin
    yield
  ensure
    # We need to be careful when cleaning up the lock key.  If we took a really long
    # time for some reason, and the lock expired, someone else may have it, and
    # it's not safe for us to remove it.  Check how much time has passed since we
    # wrote the lock key and only delete it if it hasn't expired (or we're not using
    # lock expiration)
    if @options[:expiration].nil? || end_time > Time.now.to_f
      redis.del(key)
    end
  end
end

#value ⇒ Object 



29
30
31
 
# File 'lib/redis/lock.rb', line 29

def value
  nil
end