0652bc9911
If someone else built and marked one of our dependencies, then that dependency would show up as *clean* in a later redo-ifchange, so other dependents of that file wouldn't be rebuilt. We actually have to track two session-specific variables: whether the file has been checked, and whether it was rebuilt. (Or alternatively, whether it was dirty when we checked it the first time. But we store the former.)
184 lines
5 KiB
Python
184 lines
5 KiB
Python
import sys, os, errno, glob
|
|
import vars
|
|
from helpers import unlink, relpath, debug2, mkdirp
|
|
|
|
|
|
def init():
|
|
# FIXME: just wiping out all the locks is kind of cheating. But we
|
|
# only do this from the toplevel redo process, so unless the user
|
|
# deliberately starts more than one redo on the same repository, it's
|
|
# sort of ok.
|
|
mkdirp('%s/.redo' % vars.BASE)
|
|
for f in glob.glob('%s/.redo/lock*' % vars.BASE):
|
|
os.unlink(f)
|
|
for f in glob.glob('%s/.redo/mark^*' % vars.BASE):
|
|
os.unlink(f)
|
|
for f in glob.glob('%s/.redo/built^*' % vars.BASE):
|
|
os.unlink(f)
|
|
|
|
|
|
def _sname(typ, t, fromdir=None):
|
|
# FIXME: t.replace(...) is non-reversible and non-unique here!
|
|
if fromdir:
|
|
t = os.path.join(fromdir, t)
|
|
tnew = relpath(t, vars.BASE)
|
|
v = vars.BASE + ('/.redo/%s^%s' % (typ, tnew.replace('/', '^')))
|
|
debug2('sname: (%r) %r -> %r\n' % (os.getcwd(), t, tnew))
|
|
return v
|
|
|
|
|
|
def add_dep(t, mode, dep):
|
|
debug2('add-dep(%r)\n' % t)
|
|
open(_sname('dep', t), 'a').write('%s %s\n'
|
|
% (mode, relpath(dep, vars.BASE)))
|
|
|
|
|
|
def deps(t, fromdir=None):
|
|
for line in open(_sname('dep', t, fromdir)).readlines():
|
|
assert(line[0] in ('c','m'))
|
|
assert(line[1] == ' ')
|
|
assert(line[-1] == '\n')
|
|
mode = line[0]
|
|
name = line[2:-1]
|
|
yield mode,name
|
|
|
|
|
|
def _stampname(t, fromdir=None):
|
|
return _sname('stamp', t, fromdir)
|
|
|
|
|
|
def stamp(t):
|
|
built(t)
|
|
mark(t)
|
|
stampfile = _stampname(t)
|
|
newstampfile = _sname('stamp' + str(os.getpid()), t)
|
|
depfile = _sname('dep', t)
|
|
if not os.path.exists(vars.BASE + '/.redo'):
|
|
# .redo might not exist in a 'make clean' target
|
|
return
|
|
open(newstampfile, 'w').close()
|
|
try:
|
|
mtime = os.stat(t).st_mtime
|
|
except OSError:
|
|
mtime = 0
|
|
os.utime(newstampfile, (mtime, mtime))
|
|
os.rename(newstampfile, stampfile)
|
|
open(depfile, 'a').close()
|
|
|
|
|
|
def unstamp(t, fromdir=None):
|
|
unlink(_stampname(t, fromdir))
|
|
|
|
|
|
def stamped(t, fromdir=None):
|
|
try:
|
|
stamptime = os.stat(_stampname(t, fromdir)).st_mtime
|
|
except OSError, e:
|
|
if e.errno == errno.ENOENT:
|
|
return None
|
|
else:
|
|
raise
|
|
return stamptime
|
|
|
|
|
|
def built(t, fromdir=None):
|
|
try:
|
|
open(_sname('built', t, fromdir), 'w').close()
|
|
except IOError, e:
|
|
if e.errno == errno.ENOENT:
|
|
pass # may happen if someone deletes our .redo dir
|
|
else:
|
|
raise
|
|
|
|
|
|
_builts = {}
|
|
def isbuilt(t, fromdir=None):
|
|
if _builts.get((t,fromdir)):
|
|
return True
|
|
if os.path.exists(_sname('built', t, fromdir)):
|
|
_builts[(t,fromdir)] = True
|
|
return True
|
|
|
|
|
|
def mark(t, fromdir=None):
|
|
try:
|
|
open(_sname('mark', t, fromdir), 'w').close()
|
|
except IOError, e:
|
|
if e.errno == errno.ENOENT:
|
|
pass # may happen if someone deletes our .redo dir
|
|
else:
|
|
raise
|
|
|
|
|
|
_marks = {}
|
|
def ismarked(t, fromdir=None):
|
|
if _marks.get((t,fromdir)):
|
|
return True
|
|
if os.path.exists(_sname('mark', t, fromdir)):
|
|
_marks[(t,fromdir)] = True
|
|
return True
|
|
|
|
|
|
def is_generated(t):
|
|
return os.path.exists(_sname('gen', t))
|
|
|
|
|
|
def start(t):
|
|
unstamp(t)
|
|
open(_sname('dep', t), 'w').close()
|
|
open(_sname('gen', t), 'w').close() # it's definitely a generated file
|
|
|
|
|
|
class Lock:
|
|
def __init__(self, t):
|
|
self.owned = False
|
|
self.lockname = _sname('lock', t)
|
|
self.tmpname = _sname('lock%d' % os.getpid(), t)
|
|
|
|
def __del__(self):
|
|
if self.owned:
|
|
self.unlock()
|
|
|
|
def trylock(self):
|
|
try:
|
|
os.mkfifo(self.lockname, 0600)
|
|
self.owned = True
|
|
except OSError, e:
|
|
if e.errno == errno.EEXIST:
|
|
pass
|
|
else:
|
|
raise
|
|
|
|
def unlock(self):
|
|
if not self.owned:
|
|
raise Exception("can't unlock %r - we don't own it"
|
|
% self.lockname)
|
|
# make sure no readers can connect
|
|
try:
|
|
os.rename(self.lockname, self.tmpname)
|
|
except OSError, e:
|
|
if e.errno == errno.ENOENT: # 'make clean' might do this
|
|
self.owned = False
|
|
return
|
|
try:
|
|
# ping any connected readers
|
|
os.close(os.open(self.tmpname, os.O_WRONLY|os.O_NONBLOCK))
|
|
except OSError, e:
|
|
if e.errno == errno.ENXIO: # no readers open; that's ok
|
|
pass
|
|
else:
|
|
raise
|
|
os.unlink(self.tmpname)
|
|
self.owned = False
|
|
|
|
def wait(self):
|
|
if self.owned:
|
|
raise Exception("can't wait on %r - we own it" % self.lockname)
|
|
try:
|
|
# open() will finish only when a writer exists and does close()
|
|
os.close(os.open(self.lockname, os.O_RDONLY))
|
|
except OSError, e:
|
|
if e.errno == errno.ENOENT:
|
|
pass # it's not even unlocked or was unlocked earlier
|
|
else:
|
|
raise
|