Class: Lockfile

Inherits:
Object
  • Object
show all
Defined in:
lib/lockfile.rb

Defined Under Namespace

Classes: LockError, MaxTriesLockError, NFSLockError, SleepCycle, StackingLockError, StatLockError, StolenLockError, TimeoutLockError, UnLockError

Constant Summary collapse

VERSION = 
'2.0.0'
HOSTNAME = 
Socket.gethostname
DEFAULT_RETRIES =

maximum number of attempts

nil
DEFAULT_TIMEOUT =

the longest we will try

nil
DEFAULT_MAX_AGE =

lockfiles older than this are stale

3600
DEFAULT_SLEEP_INC =

sleep cycle is this much longer each time

2
DEFAULT_MIN_SLEEP =

shortest sleep time

2
DEFAULT_MAX_SLEEP =

longest sleep time

32
DEFAULT_SUSPEND =

iff we steal a lock wait this long before we go on

1800
DEFAULT_REFRESH =

how often we touch/validate the lock

8
DEFAULT_DONT_CLEAN =

iff we leave lock files lying around

false
DEFAULT_POLL_RETRIES =

this many polls makes one ‘try’

16
DEFAULT_POLL_MAX_SLEEP =

the longest we’ll sleep between polls

0.08
DEFAULT_DONT_SWEEP =

if we cleanup after other process on our host

false
DEFAULT_DONT_USE_LOCK_ID =

if we dump lock info into lockfile

false
DEFAULT_DEBUG = 
ENV['LOCKFILE_DEBUG'] || false

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(path, opts = {}, &block) ⇒ Lockfile

Returns a new instance of Lockfile.



162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/lockfile.rb', line 162

def initialize(path, opts = {}, &block)
  @klass = self.class
  @path  = path
  @opts  = opts

  @retries          = getopt 'retries'          , @klass.retries
  @max_age          = getopt 'max_age'          , @klass.max_age
  @sleep_inc        = getopt 'sleep_inc'        , @klass.sleep_inc
  @min_sleep        = getopt 'min_sleep'        , @klass.min_sleep
  @max_sleep        = getopt 'max_sleep'        , @klass.max_sleep
  @suspend          = getopt 'suspend'          , @klass.suspend
  @timeout          = getopt 'timeout'          , @klass.timeout
  @refresh          = getopt 'refresh'          , @klass.refresh
  @dont_clean       = getopt 'dont_clean'       , @klass.dont_clean
  @poll_retries     = getopt 'poll_retries'     , @klass.poll_retries
  @poll_max_sleep   = getopt 'poll_max_sleep'   , @klass.poll_max_sleep
  @dont_sweep       = getopt 'dont_sweep'       , @klass.dont_sweep
  @dont_use_lock_id = getopt 'dont_use_lock_id' , @klass.dont_use_lock_id
  @debug            = getopt 'debug'            , @klass.debug

  @sleep_cycle = SleepCycle.new @min_sleep, @max_sleep, @sleep_inc 

  @clean    = @dont_clean ? nil : lambda{ File.unlink @path rescue nil }
  @dirname  = File.dirname @path
  @basename = File.basename @path
  @thief    = false
  @locked   = false
  @refrsher = nil

  lock(&block) if block
end

Class Attribute Details

.debug ⇒ Object

Returns the value of attribute debug.



79
80
81
 
# File 'lib/lockfile.rb', line 79

def debug
  @debug
end

.dont_clean ⇒ Object

Returns the value of attribute dont_clean.



80
81
82
 
# File 'lib/lockfile.rb', line 80

def dont_clean
  @dont_clean
end

.dont_sweep ⇒ Object

Returns the value of attribute dont_sweep.



83
84
85
 
# File 'lib/lockfile.rb', line 83

def dont_sweep
  @dont_sweep
end

.dont_use_lock_id ⇒ Object

Returns the value of attribute dont_use_lock_id.



84
85
86
 
# File 'lib/lockfile.rb', line 84

def dont_use_lock_id
  @dont_use_lock_id
end

.max_age ⇒ Object

Returns the value of attribute max_age.



72
73
74
 
# File 'lib/lockfile.rb', line 72

def max_age
  @max_age
end

.max_sleep ⇒ Object

Returns the value of attribute max_sleep.



75
76
77
 
# File 'lib/lockfile.rb', line 75

def max_sleep
  @max_sleep
end

.min_sleep ⇒ Object

Returns the value of attribute min_sleep.



74
75
76
 
# File 'lib/lockfile.rb', line 74

def min_sleep
  @min_sleep
end

.poll_max_sleep ⇒ Object

Returns the value of attribute poll_max_sleep.



82
83
84
 
# File 'lib/lockfile.rb', line 82

def poll_max_sleep
  @poll_max_sleep
end

.poll_retries ⇒ Object

Returns the value of attribute poll_retries.



81
82
83
 
# File 'lib/lockfile.rb', line 81

def poll_retries
  @poll_retries
end

.refresh ⇒ Object

Returns the value of attribute refresh.



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

def refresh
  @refresh
end

.retries ⇒ Object

Returns the value of attribute retries.



71
72
73
 
# File 'lib/lockfile.rb', line 71

def retries
  @retries
end

.sleep_inc ⇒ Object

Returns the value of attribute sleep_inc.



73
74
75
 
# File 'lib/lockfile.rb', line 73

def sleep_inc
  @sleep_inc
end

.suspend ⇒ Object

Returns the value of attribute suspend.



76
77
78
 
# File 'lib/lockfile.rb', line 76

def suspend
  @suspend
end

.timeout ⇒ Object

Returns the value of attribute timeout.



77
78
79
 
# File 'lib/lockfile.rb', line 77

def timeout
  @timeout
end

Instance Attribute Details

#basename ⇒ Object (readonly)

Returns the value of attribute basename.



117
118
119
 
# File 'lib/lockfile.rb', line 117

def basename
  @basename
end

#clean ⇒ Object (readonly)

Returns the value of attribute clean.



118
119
120
 
# File 'lib/lockfile.rb', line 118

def clean
  @clean
end

#debug ⇒ Object Also known as: debug?

Returns the value of attribute debug.



133
134
135
 
# File 'lib/lockfile.rb', line 133

def debug
  @debug
end

#dirname ⇒ Object (readonly)

Returns the value of attribute dirname.



116
117
118
 
# File 'lib/lockfile.rb', line 116

def dirname
  @dirname
end

#dont_clean ⇒ Object (readonly)

Returns the value of attribute dont_clean.



127
128
129
 
# File 'lib/lockfile.rb', line 127

def dont_clean
  @dont_clean
end

#dont_sweep ⇒ Object (readonly)

Returns the value of attribute dont_sweep.



130
131
132
 
# File 'lib/lockfile.rb', line 130

def dont_sweep
  @dont_sweep
end

#dont_use_lock_id ⇒ Object (readonly)

Returns the value of attribute dont_use_lock_id.



131
132
133
 
# File 'lib/lockfile.rb', line 131

def dont_use_lock_id
  @dont_use_lock_id
end

#klass ⇒ Object (readonly)

Returns the value of attribute klass.



110
111
112
 
# File 'lib/lockfile.rb', line 110

def klass
  @klass
end

#locked ⇒ Object (readonly) Also known as: locked?

Returns the value of attribute locked.



113
114
115
 
# File 'lib/lockfile.rb', line 113

def locked
  @locked
end

#max_age ⇒ Object (readonly)

Returns the value of attribute max_age.



120
121
122
 
# File 'lib/lockfile.rb', line 120

def max_age
  @max_age
end

#max_sleep ⇒ Object (readonly)

Returns the value of attribute max_sleep.



123
124
125
 
# File 'lib/lockfile.rb', line 123

def max_sleep
  @max_sleep
end

#min_sleep ⇒ Object (readonly)

Returns the value of attribute min_sleep.



122
123
124
 
# File 'lib/lockfile.rb', line 122

def min_sleep
  @min_sleep
end

#opts ⇒ Object (readonly)

Returns the value of attribute opts.



112
113
114
 
# File 'lib/lockfile.rb', line 112

def opts
  @opts
end

#path ⇒ Object (readonly)

Returns the value of attribute path.



111
112
113
 
# File 'lib/lockfile.rb', line 111

def path
  @path
end

#poll_max_sleep ⇒ Object (readonly)

Returns the value of attribute poll_max_sleep.



129
130
131
 
# File 'lib/lockfile.rb', line 129

def poll_max_sleep
  @poll_max_sleep
end

#poll_retries ⇒ Object (readonly)

Returns the value of attribute poll_retries.



128
129
130
 
# File 'lib/lockfile.rb', line 128

def poll_retries
  @poll_retries
end

#refresh ⇒ Object (readonly)

Returns the value of attribute refresh.



125
126
127
 
# File 'lib/lockfile.rb', line 125

def refresh
  @refresh
end

#refresher ⇒ Object (readonly)

Returns the value of attribute refresher.



115
116
117
 
# File 'lib/lockfile.rb', line 115

def refresher
  @refresher
end

#retries ⇒ Object (readonly)

Returns the value of attribute retries.



119
120
121
 
# File 'lib/lockfile.rb', line 119

def retries
  @retries
end

#sleep_inc ⇒ Object (readonly)

Returns the value of attribute sleep_inc.



121
122
123
 
# File 'lib/lockfile.rb', line 121

def sleep_inc
  @sleep_inc
end

#suspend ⇒ Object (readonly)

Returns the value of attribute suspend.



124
125
126
 
# File 'lib/lockfile.rb', line 124

def suspend
  @suspend
end

#thief ⇒ Object (readonly) Also known as: thief?

Returns the value of attribute thief.



114
115
116
 
# File 'lib/lockfile.rb', line 114

def thief
  @thief
end

#timeout ⇒ Object (readonly)

Returns the value of attribute timeout.



126
127
128
 
# File 'lib/lockfile.rb', line 126

def timeout
  @timeout
end

Class Method Details

.create(path, *a, &b) ⇒ Object 



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/lockfile.rb', line 139

def Lockfile.create(path, *a, &b)
  opts = {
    'retries' => 0,
    'min_sleep' => 0,
    'max_sleep' => 1,
    'sleep_inc' => 1,
    'max_age' => nil,
    'suspend' => 0,
    'refresh' => nil,
    'timeout' => nil,
    'poll_retries' => 0,
    'dont_clean' => true,
    'dont_sweep' => false,
    'dont_use_lock_id' => true,
  }
  begin
    new(path, opts).lock
  rescue LockError
    raise Errno::EEXIST, path
  end
  open(path, *a, &b)
end

.init ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/lockfile.rb', line 86

def init
  @retries          = DEFAULT_RETRIES
  @max_age          = DEFAULT_MAX_AGE
  @sleep_inc        = DEFAULT_SLEEP_INC
  @min_sleep        = DEFAULT_MIN_SLEEP
  @max_sleep        = DEFAULT_MAX_SLEEP
  @suspend          = DEFAULT_SUSPEND
  @timeout          = DEFAULT_TIMEOUT
  @refresh          = DEFAULT_REFRESH
  @dont_clean       = DEFAULT_DONT_CLEAN
  @poll_retries     = DEFAULT_POLL_RETRIES
  @poll_max_sleep   = DEFAULT_POLL_MAX_SLEEP
  @dont_sweep       = DEFAULT_DONT_SWEEP
  @dont_use_lock_id = DEFAULT_DONT_USE_LOCK_ID

  @debug          = DEFAULT_DEBUG

  STDOUT.sync = true if @debug
  STDERR.sync = true if @debug
end

.version ⇒ Object 



10
 
# File 'lib/lockfile.rb', line 10

def Lockfile.version() Lockfile::VERSION end

Instance Method Details

#alive?(pid) ⇒ Boolean

Returns:

  • (Boolean) 


339
340
341
342
343
344
345
346
347
 
# File 'lib/lockfile.rb', line 339

def alive? pid
  pid = Integer("#{ pid }")
  begin
    Process.kill 0, pid
    true
  rescue Errno::ESRCH
    false
  end
end

#attempt ⇒ Object 



515
516
517
518
519
 
# File 'lib/lockfile.rb', line 515

def attempt
  ret = nil
  loop{ break unless catch('attempt'){ ret = yield } == 'try_again' }
  ret
end

#create(path) ⇒ Object 



479
480
481
482
483
484
485
486
487
488
489
 
# File 'lib/lockfile.rb', line 479

def create(path)
  umask = nil 
  f = nil
  begin
    umask = File.umask 022
    f = open path, File::WRONLY|File::CREAT|File::EXCL, 0644
  ensure
    File.umask umask if umask
  end
  return(block_given? ? begin; yield f; ensure; f.close; end : f)
end

#create_tmplock ⇒ Object 



419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
 
# File 'lib/lockfile.rb', line 419

def create_tmplock
  tmplock = tmpnam @dirname
  begin
    create(tmplock) do |f|
      unless dont_use_lock_id
        @lock_id = gen_lock_id
        dumped = dump_lock_id
        trace{"lock_id <\n#{ @lock_id.inspect }\n>"}
        f.write dumped 
        f.flush
      end
      yield f
    end
  ensure
    begin; File.unlink tmplock; rescue Errno::ENOENT; end if tmplock
  end
end

#dump_lock_id(lock_id = @lock_id) ⇒ Object 



453
454
455
456
 
# File 'lib/lockfile.rb', line 453

def dump_lock_id(lock_id = @lock_id)
  "host: %s\npid: %s\nppid: %s\ntime: %s\n" %
    lock_id.values_at('host','pid','ppid','time')
end

#errmsg(e) ⇒ Object 



511
512
513
 
# File 'lib/lockfile.rb', line 511

def errmsg(e)
  "%s (%s)\n%s\n" % [e.class, e.message, e.backtrace.join("\n")]
end

#gen_lock_id ⇒ Object 



437
438
439
440
441
442
443
444
 
# File 'lib/lockfile.rb', line 437

def gen_lock_id
  Hash[
    'host' => "#{ HOSTNAME }",
    'pid' => "#{ Process.pid }",
    'ppid' => "#{ Process.ppid }",
    'time' => timestamp, 
  ]
end

#getopt(key, default = nil) ⇒ Object 



495
496
497
498
499
500
 
# File 'lib/lockfile.rb', line 495

def getopt(key, default = nil)
  [ key, key.to_s, key.to_s.intern ].each do |k|
    return @opts[k] if @opts.has_key?(k)
  end
  return default
end

#give_up! ⇒ Object 



526
527
528
 
# File 'lib/lockfile.rb', line 526

def give_up!
  throw 'attempt', 'give_up'
end

#load_lock_id(buf) ⇒ Object 



458
459
460
461
462
463
464
465
466
467
468
 
# File 'lib/lockfile.rb', line 458

def load_lock_id(buf)
  lock_id = {}
  kv = %r/([^:]+):(.*)/o
  buf.each_line do |line|
    m = kv.match line
    k, v = m[1], m[2]
    next unless m and k and v 
    lock_id[k.strip] = v.strip
  end
  lock_id
end

#lock ⇒ Object

Raises:



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
 
# File 'lib/lockfile.rb', line 194

def lock
  raise StackingLockError, "<#{ @path }> is locked!" if @locked

  sweep unless @dont_sweep

  ret = nil 

  attempt do
    begin
      @sleep_cycle.reset
      create_tmplock do |f|
        begin
          Timeout.timeout(@timeout) do
            tmp_path = f.path
            tmp_stat = f.lstat
            n_retries = 0
            trace{ "attempting to lock <#{ @path }>..." }
            begin
              i = 0
              begin
                trace{ "polling attempt <#{ i }>..." }
                begin
                  File.link tmp_path, @path
                rescue Errno::ENOENT
                  try_again!
                end
                lock_stat = File.lstat @path
                raise StatLockError, "stat's do not agree" unless
                  tmp_stat.rdev == lock_stat.rdev and tmp_stat.ino == lock_stat.ino 
                trace{ "aquired lock <#{ @path }>" }
                @locked = true
              rescue => e
                i += 1
                unless i >= @poll_retries 
                  t = [rand(@poll_max_sleep), @poll_max_sleep].min
                  trace{ "poll sleep <#{ t }>..." }
                  sleep t
                  retry
                end
                raise
              end

            rescue => e
              n_retries += 1
              trace{ "n_retries <#{ n_retries }>" }
              case validlock?
                when true
                  raise MaxTriesLockError, "surpased retries <#{ @retries }>" if 
                    @retries and n_retries >= @retries 
                  trace{ "found valid lock" }
                  sleeptime = @sleep_cycle.next 
                  trace{ "sleep <#{ sleeptime }>..." }
                  sleep sleeptime
                when false
                  trace{ "found invalid lock and removing" }
                  begin
                    File.unlink @path
                    @thief = true
                    warn "<#{ @path }> stolen by <#{ Process.pid }> at <#{ timestamp }>"
                    trace{ "i am a thief!" }
                  rescue Errno::ENOENT
                  end
                  trace{ "suspending <#{ @suspend }>" }
                  sleep @suspend
                when nil
                  raise MaxTriesLockError, "surpased retries <#{ @retries }>" if 
                    @retries and n_retries >= @retries 
              end
              retry
            end # begin
          end # timeout 
        rescue Timeout::Error
          raise TimeoutLockError, "surpassed timeout <#{ @timeout }>"
        end # begin
      end # create_tmplock

      if block_given?
        stolen = false
        @refresher = (@refresh ? new_refresher : nil) 
        begin
          begin
            ret = yield @path
          rescue StolenLockError
            stolen = true
            raise
          end
        ensure
          begin
            @refresher.kill if @refresher and @refresher.status
            @refresher = nil
          ensure
            unlock unless stolen
          end
        end
      else
        @refresher = (@refresh ? new_refresher : nil)
        ObjectSpace.define_finalizer self, @clean if @clean
        ret = self
      end
    rescue Errno::ESTALE, Errno::EIO => e
      raise(NFSLockError, errmsg(e)) 
    end
  end

  return ret
end

#new_refresher ⇒ Object 



366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
 
# File 'lib/lockfile.rb', line 366

def new_refresher
  Thread.new(Thread.current, @path, @refresh, @dont_use_lock_id) do |thread, path, refresh, dont_use_lock_id|
    loop do 
      begin
        touch path
        trace{"touched <#{ path }> @ <#{ Time.now.to_f }>"}
        unless dont_use_lock_id
          loaded = load_lock_id(IO.read(path))
          trace{"loaded <\n#{ loaded.inspect }\n>"}
          raise unless loaded == @lock_id 
        end
        sleep refresh
      rescue Exception => e
        trace{errmsg e}
        thread.raise StolenLockError
        Thread.exit
      end
    end
  end
end

#sweep ⇒ Object 



301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/lockfile.rb', line 301

def sweep
  begin
    glob = File.join(@dirname, ".*lck")
    paths = Dir[glob]
    paths.each do |path|
      begin
        basename = File.basename path
        pat = %r/^\s*\.([^_]+)_([^_]+)/o
        if pat.match(basename)
          host, pid = $1, $2
        else
          next
        end
        host.gsub!(%r/^\.+|\.+$/,'')
        quad = host.split %r/\./
        host = quad.first
        pat = %r/^\s*#{ host }/i
        if pat.match(HOSTNAME) and %r/^\s*\d+\s*$/.match(pid)
          unless alive?(pid)
            trace{ "process <#{ pid }> on <#{ host }> is no longer alive" }
            trace{ "sweeping <#{ path }>" }
            FileUtils.rm_f path
          else
            trace{ "process <#{ pid }> on <#{ host }> is still alive" }
            trace{ "ignoring <#{ path }>" }
          end
        else
          trace{ "ignoring <#{ path }> generated by <#{ host }>" }
        end
      rescue
        next
      end
    end
  rescue => e
    warn(errmsg(e))
  end
end

#timestamp ⇒ Object 



446
447
448
449
450
451
 
# File 'lib/lockfile.rb', line 446

def timestamp
  time = Time.now
  usec = time.usec.to_s
  usec << '0' while usec.size < 6
  "#{ time.strftime('%Y-%m-%d %H:%M:%S') }.#{ usec }"
end

#tmpnam(dir, seed = File.basename($0)) ⇒ Object 



470
471
472
473
474
475
476
477
 
# File 'lib/lockfile.rb', line 470

def tmpnam(dir, seed = File.basename($0))
  pid = Process.pid
  time = Time.now
  sec = time.to_i
  usec = time.usec
  "%s%s.%s_%d_%s_%d_%d_%d.lck" % 
    [dir, File::SEPARATOR, HOSTNAME, pid, seed, sec, usec, rand(sec)]
end

#to_str ⇒ Object Also known as: to_s 



502
503
504
 
# File 'lib/lockfile.rb', line 502

def to_str
  @path
end

#touch(path) ⇒ Object 



491
492
493
 
# File 'lib/lockfile.rb', line 491

def touch(path)
  FileUtils.touch path
end

#trace(s = nil) ⇒ Object 



507
508
509
 
# File 'lib/lockfile.rb', line 507

def trace(s = nil)
  STDERR.puts((s ? s : yield)) if @debug
end

#try_again! ⇒ Object Also known as: again! 



521
522
523
 
# File 'lib/lockfile.rb', line 521

def try_again!
  throw 'attempt', 'try_again'
end

#uncache(file) ⇒ Object 



401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
 
# File 'lib/lockfile.rb', line 401

def uncache file 
  refresh = nil
  begin
    is_a_file = File === file
    path = (is_a_file ? file.path : file.to_s) 
    stat = (is_a_file ? file.stat : File.stat(file.to_s)) 
    refresh = tmpnam(File.dirname(path))
    File.link path, refresh
    File.chmod stat.mode, path
    File.utime stat.atime, stat.mtime, path
  ensure 
    begin
      File.unlink refresh if refresh
    rescue Errno::ENOENT
    end
  end
end

#unlock ⇒ Object

Raises:



349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
 
# File 'lib/lockfile.rb', line 349

def unlock
  raise UnLockError, "<#{ @path }> is not locked!" unless @locked

  @refresher.kill if @refresher and @refresher.status
  @refresher = nil

  begin
    File.unlink @path
  rescue Errno::ENOENT
    raise StolenLockError, @path
  ensure
    @thief = false
    @locked = false
    ObjectSpace.undefine_finalizer self if @clean
  end
end

#validlock? ⇒ Boolean

Returns:

  • (Boolean) 


387
388
389
390
391
392
393
394
395
396
397
398
399
 
# File 'lib/lockfile.rb', line 387

def validlock?
  if @max_age
    uncache @path rescue nil
    begin
      return((Time.now - File.stat(@path).mtime) < @max_age)
    rescue Errno::ENOENT
      return nil 
    end
  else
    exist = File.exist?(@path)
    return(exist ? true : nil)
  end
end

#version ⇒ Object 



11
 
# File 'lib/lockfile.rb', line 11

def version() Lockfile::VERSION end