Class: ActiveRecord::DatabaseMutex::Implementation

Inherits:
Object
  • Object
show all
Defined in:
lib/active_record/database_mutex/implementation.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ Implementation

Creates a mutex with the name given with the option :name.



7
8
9
 
# File 'lib/active_record/database_mutex/implementation.rb', line 7

def initialize(opts = {})
  @name = opts[:name] or raise ArgumentError, "mutex requires a :name argument"
end

Instance Attribute Details

#name ⇒ Object (readonly)

Returns the name of this mutex as given as a constructor argument.



12
13
14
 
# File 'lib/active_record/database_mutex/implementation.rb', line 12

def name
  @name
end

Instance Method Details

#aquired_lock? ⇒ Boolean

Returns true if this mutex is locked by this database connection.

Returns:

  • (Boolean) 


98
99
100
 
# File 'lib/active_record/database_mutex/implementation.rb', line 98

def aquired_lock?
  query("SELECT CONNECTION_ID() = IS_USED_LOCK(#{quote(name)})") == 1
end

#lock(opts = {}) ⇒ Object

Locks the mutex and returns true if successful. If the mutex is already locked and the timeout in seconds is given as the :timeout option, this method raises a MutexLocked exception after that many seconds. If the :timeout option wasn’t given, this method blocks until the lock could be aquired.



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/active_record/database_mutex/implementation.rb', line 42

def lock(opts = {})
  if opts[:nonblock] # XXX document
    begin
      lock_with_timeout :timeout => 0
    rescue MutexLocked
    end
  elsif opts[:timeout]
    lock_with_timeout opts
  else
    spin_timeout = opts[:spin_timeout] || 1 # XXX document
    begin
      lock_with_timeout :timeout => spin_timeout
    rescue MutexLocked
      retry
    end
  end
end

#locked? ⇒ Boolean

Returns true if this mutex is locked at the moment.

Returns:

  • (Boolean) 


93
94
95
 
# File 'lib/active_record/database_mutex/implementation.rb', line 93

def locked?
  not unlocked?
end

#not_aquired_lock? ⇒ Boolean

Returns true if this mutex is not locked by this database connection.

Returns:

  • (Boolean) 


103
104
105
 
# File 'lib/active_record/database_mutex/implementation.rb', line 103

def not_aquired_lock?
  not aquired_lock?
end

#synchronize(opts = {}) ⇒ Object

Locks the mutex if it isn’t already locked via another database connection and yields to the given block. After executing the block’s content the mutex is unlocked (only if it was locked by this synchronize method before).

If the mutex was already locked by another database connection the method blocks until it could aquire the lock and only then the block’s content is executed. If the mutex was already locked by the current database connection then the block’s content is run and the the mutex isn’t unlocked afterwards.

If a value in seconds is passed to the :timeout option the blocking ends after that many seconds and the method returns immediately if the lock couldn’t be aquired during that time.



28
29
30
31
32
33
34
35
 
# File 'lib/active_record/database_mutex/implementation.rb', line 28

def synchronize(opts = {})
  locked = lock(opts) or return
  yield
rescue ActiveRecord::DatabaseMutex::MutexLocked
  return nil
ensure
  locked and unlock
end

#to_s ⇒ Object Also known as: inspect

Returns a string representation of this DatabaseMutex instance.



108
109
110
 
# File 'lib/active_record/database_mutex/implementation.rb', line 108

def to_s
  "#<#{self.class} #{name}>"
end

#unlock ⇒ Object

Unlocks the mutex and returns true if successful. Otherwise this method raises a MutexLocked exception.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/active_record/database_mutex/implementation.rb', line 62

def unlock(*)
  if aquired_lock?
    decrease_counter
    if counter_zero?
      case query("SELECT RELEASE_LOCK(#{quote(name)})")
      when 1
        true
      when 0, nil
        raise MutexUnlockFailed, "unlocking of mutex '#{name}' failed"
      end
    end
  else
    raise MutexUnlockFailed, "unlocking of mutex '#{name}' failed"
  end
end

#unlock?(*a) ⇒ Boolean

Unlock this mutex and return self if successful, otherwise (the mutex was not locked) nil is returned.

Returns:

  • (Boolean) 


80
81
82
83
84
85
 
# File 'lib/active_record/database_mutex/implementation.rb', line 80

def unlock?(*a)
  unlock(*a)
  self
rescue MutexUnlockFailed
  nil
end

#unlocked? ⇒ Boolean

Returns true if this mutex is unlocked at the moment.

Returns:

  • (Boolean) 


88
89
90
 
# File 'lib/active_record/database_mutex/implementation.rb', line 88

def unlocked?
  query("SELECT IS_FREE_LOCK(#{quote(name)})") == 1
end