Class: Arrow::Session::Lock

Inherits:

Arrow::Object

• Object
• Arrow::Object
• Arrow::Session::Lock

show all

Includes:

PluginFactory

Defined in:

lib/arrow/session/lock.rb

Overview

  Release a shared lock on the session data.

Constant Summary

UNLOCKED =

Lock status flags

0b00

READ =

0b01

WRITE =

0b10

Class Method Summary

• + (Object) create(uri, id)

  Create a new Arrow::Session::Lock object for the given id of the type specified by uri.

• + (Object) derivativeDirs

  Returns the Array of directories to search for derivatives; part of the PluginFactory interface.

Instance Method Summary

• - (Object) acquire_read_lock(blocking) protected

  Interface method for concrete derivatives: acquire a read lock through whatever mechanism is being implemented.

• - (Object) acquire_write_lock(blocking) protected

  Interface method for concrete derivatives: acquire a write lock through whatever mechanism is being implemented.

• - (Object) finish

  Indicate to the lock that the caller will no longer be using it, and it may free any resources it had been using.

• - (Lock) initialize(uri, id) constructor

  Create a new Arrow::Session::Lock object.

• - (Boolean) locked?

  Returns true if the lock object currently holds either a read or write lock.

• - (Object) read_lock(blocking = true)

  Acquire a read (shared) lock.

• - (Boolean) read_locked?

  Returns true if the lock object has acquired a read lock.

• - (Object) read_unlock

  Give up a read (shared) lock.

• - (Object) release_all_locks

  Release any locks acquired by this lock object.

• - (Object) release_read_lock protected

  Interface method for concrete derivatives: release a read lock through whatever mechanism is being implemented.

• - (Object) release_write_lock protected

  Interface method for concrete derivatives: release a write lock through whatever mechanism is being implemented.

• - (Object) with_read_lock(blocking = true)

  Execute the given block after obtaining a read lock, and give up the lock when the block returns.

• - (Object) with_write_lock(blocking = true)

  Execute the given block after obtaining a write lock, and give up the lock when the block returns.

• - (Object) write_lock(blocking = true)

  Acquire a write (exclusive) lock.

• - (Boolean) write_locked?

  Returns true if the lock object has acquired a write lock.

• - (Object) write_unlock

  Release a write (exclusive) lock.

Methods inherited from Arrow::Object

deprecate_class_method, deprecate_method, inherited

Methods included from Arrow::Loggable

#log

82
83
84
85

# File 'lib/arrow/session/lock.rb', line 82

def initialize( uri, id )
  super()
  @status = UNLOCKED
end

69
70
71
72
73

# File 'lib/arrow/session/lock.rb', line 69

def self::create( uri, id )
  uri = Arrow::Session.parse_uri( uri ) if
    uri.is_a?( String )
  super( uri.scheme.dup, uri, id )
end

62
63
64

# File 'lib/arrow/session/lock.rb', line 62

def self::derivativeDirs
  [ 'arrow/session', 'arrow/session/lock' ]
end

211
212
213
214
215

# File 'lib/arrow/session/lock.rb', line 211

def acquire_read_lock( blocking )
  raise UnimplementedError,
    "%s does not provide an implementation of #acquire_read_lock." %
    self.class.name
end

225
226
227
228
229

# File 'lib/arrow/session/lock.rb', line 225

def acquire_write_lock( blocking )
  raise UnimplementedError,
    "%s does not provide an implementation of #acquire_write_lock." %
    self.class.name
end

195
196
197

# File 'lib/arrow/session/lock.rb', line 195

def finish
  self.release_all_locks
end

146
147
148

# File 'lib/arrow/session/lock.rb', line 146

def locked?
  (@status & (READ|WRITE)).nonzero?
end

94
95
96
97
98
99
100
101

# File 'lib/arrow/session/lock.rb', line 94

def read_lock( blocking=true )
  return true if self.read_locked?
  self.log.debug "Acquiring read lock"
  self.acquire_read_lock( blocking ) or return false
  @status |= READ
  self.log.debug "Got read lock"
  return true
end

152
153
154

# File 'lib/arrow/session/lock.rb', line 152

def read_locked?
  (@status & READ).nonzero?
end

165
166
167
168
169
170
171

# File 'lib/arrow/session/lock.rb', line 165

def read_unlock
  raise Arrow::LockingError, "No read lock to release" unless
    self.read_locked?
  self.log.debug "Releasing read lock"
  self.release_read_lock
  @status &= ( @status ^ READ )
end

186
187
188
189
190

# File 'lib/arrow/session/lock.rb', line 186

def release_all_locks
  return false unless self.locked?
  self.write_unlock if self.write_locked?
  self.read_unlock if self.read_locked?
end

235
236
237
238
239

# File 'lib/arrow/session/lock.rb', line 235

def release_read_lock
  raise UnimplementedError,
    "%s does not provide an implementation of #release_read_lock." %
    self.class.name
end

245
246
247
248
249

# File 'lib/arrow/session/lock.rb', line 245

def release_write_lock
  raise UnimplementedError,
    "%s does not provide an implementation of #release_write_lock." %
    self.class.name
end

120
121
122
123
124
125
126
127

# File 'lib/arrow/session/lock.rb', line 120

def with_read_lock( blocking=true )
  begin
    self.read_lock( blocking ) or raise Errno::EAGAIN
    yield
  ensure
    self.release_read_lock
  end
end

134
135
136
137
138
139
140
141

# File 'lib/arrow/session/lock.rb', line 134

def with_write_lock( blocking=true )
  begin
    self.write_lock( blocking ) or raise Errno::EAGAIN
    yield
  ensure
    self.release_write_lock
  end
end

106
107
108
109
110
111
112
113

# File 'lib/arrow/session/lock.rb', line 106

def write_lock( blocking=true )
  return true if self.write_locked?
  self.log.debug "Acquiring write lock"
  self.acquire_write_lock( blocking ) or return false
  @status |= WRITE
  self.log.debug "Got write lock"
  return true
end

158
159
160

# File 'lib/arrow/session/lock.rb', line 158

def write_locked?
  (@status & WRITE).nonzero?
end

176
177
178
179
180
181
182

# File 'lib/arrow/session/lock.rb', line 176

def write_unlock
  raise Arrow::LockingError, "No write lock to release" unless
    self.write_locked?
  self.log.debug "Releasing write lock"
  self.release_write_lock
  @status &= ( @status ^ WRITE )
end