transaction.py
764 lines
| 25.9 KiB
| text/x-python
|
PythonLexer
/ mercurial / transaction.py
|
r17424 | # transaction.py - simple journaling scheme for mercurial | ||
|
r0 | # | ||
# This transaction scheme is intended to gracefully handle program | ||||
# errors and interruptions. More serious failures like system crashes | ||||
# can be recovered with an fsck-like tool. As the whole repository is | ||||
# effectively log-structured, this should amount to simply truncating | ||||
# anything that isn't referenced in the changelog. | ||||
# | ||||
|
r47575 | # Copyright 2005, 2006 Olivia Mackall <olivia@selenic.com> | ||
|
r0 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r0 | |||
|
r25986 | from __future__ import absolute_import | ||
|
r20886 | import errno | ||
|
r25986 | |||
from .i18n import _ | ||||
from . import ( | ||||
error, | ||||
|
r36753 | pycompat, | ||
|
r25986 | util, | ||
) | ||||
|
r43346 | from .utils import stringutil | ||
|
r8289 | |||
|
r23313 | version = 2 | ||
|
r23064 | |||
|
r28830 | # These are the file generators that should only be executed after the | ||
# finalizers are done, since they rely on the output of the finalizers (like | ||||
# the changelog having been written). | ||||
|
r43347 | postfinalizegenerators = {b'bookmarks', b'dirstate'} | ||
|
r28830 | |||
r44886 | GEN_GROUP_ALL = b'all' | |||
GEN_GROUP_PRE_FINALIZE = b'prefinalize' | ||||
GEN_GROUP_POST_FINALIZE = b'postfinalize' | ||||
|
r43346 | |||
|
r28830 | |||
|
r8289 | def active(func): | ||
def _active(self, *args, **kwds): | ||||
|
r39710 | if self._count == 0: | ||
|
r46330 | raise error.ProgrammingError( | ||
b'cannot use transaction when it is already committed/aborted' | ||||
|
r43346 | ) | ||
|
r8289 | return func(self, *args, **kwds) | ||
|
r43346 | |||
|
r8289 | return _active | ||
|
r0 | |||
|
r43346 | |||
def _playback( | ||||
journal, | ||||
report, | ||||
opener, | ||||
vfsmap, | ||||
entries, | ||||
backupentries, | ||||
unlink=True, | ||||
checkambigfiles=None, | ||||
): | ||||
|
r46481 | for f, o in entries: | ||
|
r8294 | if o or not unlink: | ||
|
r43347 | checkambig = checkambigfiles and (f, b'') in checkambigfiles | ||
|
r8294 | try: | ||
|
r43347 | fp = opener(f, b'a', checkambig=checkambig) | ||
|
r43233 | if fp.tell() < o: | ||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b"attempted to truncate %s to %d bytes, but it was " | ||
b"already %d bytes\n" | ||||
|
r43346 | ) | ||
% (f, o, fp.tell()) | ||||
) | ||||
|
r13400 | fp.truncate(o) | ||
fp.close() | ||||
|
r9686 | except IOError: | ||
|
r43347 | report(_(b"failed to truncate %s\n") % f) | ||
|
r8294 | raise | ||
else: | ||||
try: | ||||
|
r20084 | opener.unlink(f) | ||
|
r25660 | except (IOError, OSError) as inst: | ||
|
r8294 | if inst.errno != errno.ENOENT: | ||
raise | ||||
|
r20882 | |||
backupfiles = [] | ||||
|
r23309 | for l, f, b, c in backupentries: | ||
|
r23312 | if l not in vfsmap and c: | ||
|
r43347 | report(b"couldn't handle %s: unknown cache location %s\n" % (b, l)) | ||
|
r23311 | vfs = vfsmap[l] | ||
|
r23312 | try: | ||
if f and b: | ||||
filepath = vfs.join(f) | ||||
backuppath = vfs.join(b) | ||||
|
r33279 | checkambig = checkambigfiles and (f, l) in checkambigfiles | ||
|
r23312 | try: | ||
|
r33279 | util.copyfile(backuppath, filepath, checkambig=checkambig) | ||
|
r23312 | backupfiles.append(b) | ||
except IOError: | ||||
|
r43347 | report(_(b"failed to recover %s\n") % f) | ||
|
r23312 | else: | ||
target = f or b | ||||
try: | ||||
vfs.unlink(target) | ||||
|
r25660 | except (IOError, OSError) as inst: | ||
|
r23312 | if inst.errno != errno.ENOENT: | ||
raise | ||||
|
r41401 | except (IOError, OSError, error.Abort): | ||
|
r23312 | if not c: | ||
|
r23278 | raise | ||
|
r20882 | |||
|
r43347 | backuppath = b"%s.backupfiles" % journal | ||
|
r20882 | if opener.exists(backuppath): | ||
opener.unlink(backuppath) | ||||
|
r26753 | opener.unlink(journal) | ||
|
r23312 | try: | ||
for f in backupfiles: | ||||
if opener.exists(f): | ||||
opener.unlink(f) | ||||
|
r41401 | except (IOError, OSError, error.Abort): | ||
|
r23312 | # only pure backup file remains, it is sage to ignore any error | ||
pass | ||||
|
r8294 | |||
|
r43346 | |||
|
r33790 | class transaction(util.transactional): | ||
|
r43346 | def __init__( | ||
self, | ||||
report, | ||||
opener, | ||||
vfsmap, | ||||
journalname, | ||||
undoname=None, | ||||
after=None, | ||||
createmode=None, | ||||
validator=None, | ||||
releasefn=None, | ||||
checkambigfiles=None, | ||||
|
r43906 | name='<unnamed>', | ||
|
r43346 | ): | ||
|
r20881 | """Begin a new transaction | ||
Begins a new transaction that allows rolling back writes in the event of | ||||
an exception. | ||||
* `after`: called after the transaction has been committed | ||||
* `createmode`: the mode of the journal file that will be created | ||||
|
r26576 | * `releasefn`: called after releasing (with transaction and result) | ||
|
r33278 | |||
`checkambigfiles` is a set of (path, vfs-location) tuples, | ||||
which determine whether file stat ambiguity should be avoided | ||||
for corresponded files. | ||||
|
r20881 | """ | ||
|
r39710 | self._count = 1 | ||
self._usages = 1 | ||||
|
r39719 | self._report = report | ||
|
r23310 | # a vfs to the store content | ||
|
r39718 | self._opener = opener | ||
|
r23310 | # a map to access file in various {location -> vfs} | ||
vfsmap = vfsmap.copy() | ||||
|
r43347 | vfsmap[b''] = opener # set default value | ||
|
r23310 | self._vfsmap = vfsmap | ||
|
r39717 | self._after = after | ||
|
r46483 | self._offsetmap = {} | ||
|
r46484 | self._newfiles = set() | ||
|
r39712 | self._journal = journalname | ||
|
r39711 | self._undoname = undoname | ||
|
r23279 | self._queue = [] | ||
|
r26576 | # A callback to do something just after releasing transaction. | ||
if releasefn is None: | ||||
releasefn = lambda tr, success: None | ||||
|
r39714 | self._releasefn = releasefn | ||
|
r26576 | |||
|
r39716 | self._checkambigfiles = set() | ||
|
r33278 | if checkambigfiles: | ||
|
r39716 | self._checkambigfiles.update(checkambigfiles) | ||
|
r33278 | |||
|
r39721 | self._names = [name] | ||
|
r36837 | |||
|
r32261 | # A dict dedicated to precisely tracking the changes introduced in the | ||
# transaction. | ||||
self.changes = {} | ||||
|
r23279 | # a dict of arguments to be passed to hooks | ||
self.hookargs = {} | ||||
|
r46483 | self._file = opener.open(self._journal, b"w+") | ||
|
r23279 | |||
|
r23309 | # a list of ('location', 'path', 'backuppath', cache) entries. | ||
|
r23311 | # - if 'backuppath' is empty, no file existed at backup time | ||
# - if 'path' is empty, this is a temporary transaction file | ||||
# - if 'location' is not empty, the path is outside main opener reach. | ||||
# use 'location' value as a key in a vfsmap to find the right 'vfs' | ||||
# (cache is currently unused) | ||||
|
r23249 | self._backupentries = [] | ||
self._backupmap = {} | ||||
|
r43347 | self._backupjournal = b"%s.backupfiles" % self._journal | ||
self._backupsfile = opener.open(self._backupjournal, b'w') | ||||
self._backupsfile.write(b'%d\n' % version) | ||||
|
r23279 | |||
|
r6065 | if createmode is not None: | ||
|
r39712 | opener.chmod(self._journal, createmode & 0o666) | ||
|
r25658 | opener.chmod(self._backupjournal, createmode & 0o666) | ||
|
r0 | |||
|
r22078 | # hold file generations to be performed on commit | ||
self._filegenerators = {} | ||||
|
r23543 | # hold callback to write pending data for hooks | ||
|
r23202 | self._pendingcallback = {} | ||
# True is any pending data have been written ever | ||||
self._anypending = False | ||||
|
r23204 | # holds callback to call when writing the transaction | ||
self._finalizecallback = {} | ||||
|
r45031 | # holds callback to call when validating the transaction | ||
# should raise exception if anything is wrong | ||||
self._validatecallback = {} | ||||
if validator is not None: | ||||
self._validatecallback[b'001-userhooks'] = validator | ||||
|
r23543 | # hold callback for post transaction close | ||
|
r23220 | self._postclosecallback = {} | ||
|
r23764 | # holds callbacks to call during abort | ||
self._abortcallback = {} | ||||
|
r22078 | |||
|
r36837 | def __repr__(self): | ||
|
r43906 | name = '/'.join(self._names) | ||
return '<transaction name=%s, count=%d, usages=%d>' % ( | ||||
|
r43346 | name, | ||
self._count, | ||||
self._usages, | ||||
) | ||||
|
r36837 | |||
|
r0 | def __del__(self): | ||
|
r39712 | if self._journal: | ||
|
r9693 | self._abort() | ||
|
r0 | |||
|
r8289 | @active | ||
|
r8363 | def startgroup(self): | ||
|
r23250 | """delay registration of file entry | ||
This is used by strip to delay vision of strip offset. The transaction | ||||
sees either none or all of the strip actions to be done.""" | ||||
|
r23251 | self._queue.append([]) | ||
|
r8363 | |||
@active | ||||
def endgroup(self): | ||||
|
r23250 | """apply delayed registration of file entry. | ||
This is used by strip to delay vision of strip offset. The transaction | ||||
sees either none or all of the strip actions to be done.""" | ||||
|
r8363 | q = self._queue.pop() | ||
|
r46481 | for f, o in q: | ||
self._addentry(f, o) | ||||
|
r8363 | |||
@active | ||||
|
r46481 | def add(self, file, offset): | ||
|
r23252 | """record the state of an append-only file before update""" | ||
|
r46484 | if ( | ||
file in self._newfiles | ||||
or file in self._offsetmap | ||||
or file in self._backupmap | ||||
): | ||||
|
r10282 | return | ||
|
r8363 | if self._queue: | ||
|
r46481 | self._queue[-1].append((file, offset)) | ||
|
r8363 | return | ||
|
r46481 | self._addentry(file, offset) | ||
|
r23253 | |||
|
r46481 | def _addentry(self, file, offset): | ||
|
r23253 | """add a append-only entry to memory and on-disk state""" | ||
|
r46484 | if ( | ||
file in self._newfiles | ||||
or file in self._offsetmap | ||||
or file in self._backupmap | ||||
): | ||||
|
r23253 | return | ||
|
r46484 | if offset: | ||
self._offsetmap[file] = offset | ||||
else: | ||||
self._newfiles.add(file) | ||||
|
r0 | # add enough data to the journal to do the truncate | ||
|
r43347 | self._file.write(b"%s\0%d\n" % (file, offset)) | ||
|
r39713 | self._file.flush() | ||
|
r0 | |||
|
r8289 | @active | ||
|
r43347 | def addbackup(self, file, hardlink=True, location=b''): | ||
|
r20882 | """Adds a backup of the file to the transaction | ||
Calling addbackup() creates a hardlink backup of the specified file | ||||
that is used to recover the file in the event of the transaction | ||||
aborting. | ||||
* `file`: the file path, relative to .hg/store | ||||
* `hardlink`: use a hardlink to quickly create the backup | ||||
""" | ||||
|
r23251 | if self._queue: | ||
|
r43347 | msg = b'cannot use transaction.addbackup inside "group"' | ||
|
r31648 | raise error.ProgrammingError(msg) | ||
|
r20882 | |||
|
r46484 | if ( | ||
file in self._newfiles | ||||
or file in self._offsetmap | ||||
or file in self._backupmap | ||||
): | ||||
|
r20882 | return | ||
|
r23582 | vfs = self._vfsmap[location] | ||
dirname, filename = vfs.split(file) | ||||
|
r43347 | backupfilename = b"%s.backup.%s" % (self._journal, filename) | ||
|
r23581 | backupfile = vfs.reljoin(dirname, backupfilename) | ||
|
r22663 | if vfs.exists(file): | ||
filepath = vfs.join(file) | ||||
|
r23314 | backuppath = vfs.join(backupfile) | ||
|
r23900 | util.copyfile(filepath, backuppath, hardlink=hardlink) | ||
|
r20882 | else: | ||
|
r43347 | backupfile = b'' | ||
|
r20882 | |||
|
r23316 | self._addbackupentry((location, file, backupfile, False)) | ||
|
r23283 | |||
def _addbackupentry(self, entry): | ||||
"""register a new backup entry and write it to disk""" | ||||
self._backupentries.append(entry) | ||||
|
r25294 | self._backupmap[entry[1]] = len(self._backupentries) - 1 | ||
|
r43347 | self._backupsfile.write(b"%s\0%s\0%s\0%d\n" % entry) | ||
|
r23249 | self._backupsfile.flush() | ||
|
r20882 | |||
@active | ||||
|
r43347 | def registertmp(self, tmpfile, location=b''): | ||
|
r23291 | """register a temporary transaction file | ||
|
r23355 | Such files will be deleted when the transaction exits (on both | ||
failure and success). | ||||
|
r23291 | """ | ||
|
r43347 | self._addbackupentry((location, b'', tmpfile, False)) | ||
|
r23291 | |||
@active | ||||
|
r43347 | def addfilegenerator( | ||
self, genid, filenames, genfunc, order=0, location=b'' | ||||
): | ||||
|
r22078 | """add a function to generates some files at transaction commit | ||
The `genfunc` argument is a function capable of generating proper | ||||
content of each entry in the `filename` tuple. | ||||
At transaction close time, `genfunc` will be called with one file | ||||
object argument per entries in `filenames`. | ||||
The transaction itself is responsible for the backup, creation and | ||||
final write of such file. | ||||
The `genid` argument is used to ensure the same set of file is only | ||||
generated once. Call to `addfilegenerator` for a `genid` already | ||||
present will overwrite the old entry. | ||||
The `order` argument may be used to control the order in which multiple | ||||
generator will be executed. | ||||
|
r23317 | |||
The `location` arguments may be used to indicate the files are located | ||||
outside of the the standard directory for transaction. It should match | ||||
|
r23543 | one of the key of the `transaction.vfsmap` dictionary. | ||
|
r22078 | """ | ||
|
r22663 | # For now, we are unable to do proper backup and restore of custom vfs | ||
# but for bookmarks that are handled outside this mechanism. | ||||
|
r23317 | self._filegenerators[genid] = (order, filenames, genfunc, location) | ||
|
r22078 | |||
|
r33056 | @active | ||
def removefilegenerator(self, genid): | ||||
"""reverse of addfilegenerator, remove a file generator function""" | ||||
if genid in self._filegenerators: | ||||
del self._filegenerators[genid] | ||||
r44886 | def _generatefiles(self, suffix=b'', group=GEN_GROUP_ALL): | |||
|
r23102 | # write files registered for generation | ||
|
r23357 | any = False | ||
r44887 | ||||
if group == GEN_GROUP_ALL: | ||||
skip_post = skip_pre = False | ||||
else: | ||||
skip_pre = group == GEN_GROUP_POST_FINALIZE | ||||
skip_post = group == GEN_GROUP_PRE_FINALIZE | ||||
|
r43376 | for id, entry in sorted(pycompat.iteritems(self._filegenerators)): | ||
|
r23357 | any = True | ||
|
r23317 | order, filenames, genfunc, location = entry | ||
|
r28830 | |||
# for generation at closing, check if it's before or after finalize | ||||
r44887 | is_post = id in postfinalizegenerators | |||
if skip_post and is_post: | ||||
continue | ||||
elif skip_pre and not is_post: | ||||
|
r28830 | continue | ||
|
r23317 | vfs = self._vfsmap[location] | ||
|
r23102 | files = [] | ||
try: | ||||
for name in filenames: | ||||
|
r23356 | name += suffix | ||
if suffix: | ||||
self.registertmp(name, location=location) | ||||
|
r33279 | checkambig = False | ||
|
r23356 | else: | ||
self.addbackup(name, location=location) | ||||
|
r39716 | checkambig = (name, location) in self._checkambigfiles | ||
|
r43346 | files.append( | ||
|
r43347 | vfs(name, b'w', atomictemp=True, checkambig=checkambig) | ||
|
r43346 | ) | ||
|
r23102 | genfunc(*files) | ||
|
r41140 | for f in files: | ||
f.close() | ||||
# skip discard() loop since we're sure no open file remains | ||||
del files[:] | ||||
|
r23102 | finally: | ||
for f in files: | ||||
|
r41140 | f.discard() | ||
|
r23357 | return any | ||
|
r23102 | |||
|
r22078 | @active | ||
|
r46482 | def findoffset(self, file): | ||
|
r46484 | if file in self._newfiles: | ||
return 0 | ||||
|
r46483 | return self._offsetmap.get(file) | ||
@active | ||||
def readjournal(self): | ||||
self._file.seek(0) | ||||
entries = [] | ||||
|
r46680 | for l in self._file.readlines(): | ||
|
r46483 | file, troffset = l.split(b'\0') | ||
entries.append((file, int(troffset))) | ||||
return entries | ||||
|
r2084 | |||
|
r8289 | @active | ||
|
r46481 | def replace(self, file, offset): | ||
|
r46554 | """ | ||
|
r8363 | replace can only replace already committed entries | ||
that are not pending in the queue | ||||
|
r46554 | """ | ||
|
r46484 | if file in self._newfiles: | ||
if not offset: | ||||
return | ||||
self._newfiles.remove(file) | ||||
self._offsetmap[file] = offset | ||||
elif file in self._offsetmap: | ||||
if not offset: | ||||
del self._offsetmap[file] | ||||
self._newfiles.add(file) | ||||
else: | ||||
self._offsetmap[file] = offset | ||||
else: | ||||
|
r2084 | raise KeyError(file) | ||
|
r43347 | self._file.write(b"%s\0%d\n" % (file, offset)) | ||
|
r39713 | self._file.flush() | ||
|
r2084 | |||
|
r8289 | @active | ||
|
r43906 | def nest(self, name='<unnamed>'): | ||
|
r39710 | self._count += 1 | ||
self._usages += 1 | ||||
|
r39721 | self._names.append(name) | ||
|
r1806 | return self | ||
|
r11230 | def release(self): | ||
|
r39710 | if self._count > 0: | ||
self._usages -= 1 | ||||
|
r39721 | if self._names: | ||
self._names.pop() | ||||
|
r11685 | # if the transaction scopes are left without being closed, fail | ||
|
r39710 | if self._count > 0 and self._usages == 0: | ||
|
r11230 | self._abort() | ||
|
r1806 | def running(self): | ||
|
r39710 | return self._count > 0 | ||
|
r1806 | |||
|
r23202 | def addpending(self, category, callback): | ||
"""add a callback to be called when the transaction is pending | ||||
|
r23280 | The transaction will be given as callback's first argument. | ||
|
r23202 | Category is a unique identifier to allow overwriting an old callback | ||
with a newer callback. | ||||
""" | ||||
self._pendingcallback[category] = callback | ||||
@active | ||||
def writepending(self): | ||||
|
r46554 | """write pending file to temporary version | ||
|
r23202 | |||
|
r46554 | This is used to allow hooks to view a transaction before commit""" | ||
|
r23202 | categories = sorted(self._pendingcallback) | ||
for cat in categories: | ||||
# remove callback since the data will have been flushed | ||||
|
r23280 | any = self._pendingcallback.pop(cat)(self) | ||
|
r23202 | self._anypending = self._anypending or any | ||
|
r43347 | self._anypending |= self._generatefiles(suffix=b'.pending') | ||
|
r23202 | return self._anypending | ||
|
r8289 | @active | ||
r44508 | def hasfinalize(self, category): | |||
|
r46554 | """check is a callback already exist for a category""" | ||
r44508 | return category in self._finalizecallback | |||
@active | ||||
|
r23204 | def addfinalize(self, category, callback): | ||
"""add a callback to be called when the transaction is closed | ||||
|
r23281 | The transaction will be given as callback's first argument. | ||
|
r23204 | Category is a unique identifier to allow overwriting old callbacks with | ||
newer callbacks. | ||||
""" | ||||
self._finalizecallback[category] = callback | ||||
@active | ||||
|
r23220 | def addpostclose(self, category, callback): | ||
|
r33087 | """add or replace a callback to be called after the transaction closed | ||
|
r23220 | |||
|
r23282 | The transaction will be given as callback's first argument. | ||
|
r23220 | Category is a unique identifier to allow overwriting an old callback | ||
with a newer callback. | ||||
""" | ||||
self._postclosecallback[category] = callback | ||||
@active | ||||
|
r33087 | def getpostclose(self, category): | ||
"""return a postclose callback added before, or None""" | ||||
return self._postclosecallback.get(category, None) | ||||
@active | ||||
|
r23764 | def addabort(self, category, callback): | ||
"""add a callback to be called when the transaction is aborted. | ||||
The transaction will be given as the first argument to the callback. | ||||
Category is a unique identifier to allow overwriting an old callback | ||||
with a newer callback. | ||||
""" | ||||
self._abortcallback[category] = callback | ||||
@active | ||||
|
r45031 | def addvalidator(self, category, callback): | ||
|
r46554 | """adds a callback to be called when validating the transaction. | ||
|
r45031 | |||
The transaction will be given as the first argument to the callback. | ||||
|
r46554 | callback should raise exception if to abort transaction""" | ||
|
r45031 | self._validatecallback[category] = callback | ||
@active | ||||
|
r0 | def close(self): | ||
|
r9220 | '''commit the transaction''' | ||
|
r39710 | if self._count == 1: | ||
|
r45031 | for category in sorted(self._validatecallback): | ||
self._validatecallback[category](self) | ||||
self._validatecallback = None # Help prevent cycles. | ||||
r44886 | self._generatefiles(group=GEN_GROUP_PRE_FINALIZE) | |||
r44556 | while self._finalizecallback: | |||
callbacks = self._finalizecallback | ||||
self._finalizecallback = {} | ||||
categories = sorted(callbacks) | ||||
for cat in categories: | ||||
callbacks[cat](self) | ||||
|
r28960 | # Prevent double usage and help clear cycles. | ||
self._finalizecallback = None | ||||
r44886 | self._generatefiles(group=GEN_GROUP_POST_FINALIZE) | |||
|
r20881 | |||
|
r39710 | self._count -= 1 | ||
if self._count != 0: | ||||
|
r1806 | return | ||
|
r39713 | self._file.close() | ||
|
r23249 | self._backupsfile.close() | ||
|
r23291 | # cleanup temporary files | ||
|
r23312 | for l, f, b, c in self._backupentries: | ||
if l not in self._vfsmap and c: | ||||
|
r43346 | self._report( | ||
|
r43347 | b"couldn't remove %s: unknown cache location %s\n" % (b, l) | ||
|
r43346 | ) | ||
|
r23312 | continue | ||
|
r23311 | vfs = self._vfsmap[l] | ||
if not f and b and vfs.exists(b): | ||||
|
r23312 | try: | ||
vfs.unlink(b) | ||||
|
r26587 | except (IOError, OSError, error.Abort) as inst: | ||
|
r23312 | if not c: | ||
raise | ||||
# Abort may be raise by read only opener | ||||
|
r43346 | self._report( | ||
|
r43347 | b"couldn't remove %s: %s\n" % (vfs.join(b), inst) | ||
|
r43346 | ) | ||
|
r46483 | self._offsetmap = {} | ||
|
r46484 | self._newfiles = set() | ||
|
r23904 | self._writeundo() | ||
|
r39717 | if self._after: | ||
self._after() | ||||
|
r43346 | self._after = None # Help prevent cycles. | ||
|
r39718 | if self._opener.isfile(self._backupjournal): | ||
self._opener.unlink(self._backupjournal) | ||||
if self._opener.isfile(self._journal): | ||||
self._opener.unlink(self._journal) | ||||
|
r27662 | for l, _f, b, c in self._backupentries: | ||
if l not in self._vfsmap and c: | ||||
|
r43346 | self._report( | ||
|
r43347 | b"couldn't remove %s: unknown cache location" | ||
b"%s\n" % (b, l) | ||||
|
r43346 | ) | ||
|
r27662 | continue | ||
vfs = self._vfsmap[l] | ||||
if b and vfs.exists(b): | ||||
try: | ||||
vfs.unlink(b) | ||||
except (IOError, OSError, error.Abort) as inst: | ||||
if not c: | ||||
raise | ||||
# Abort may be raise by read only opener | ||||
|
r43346 | self._report( | ||
|
r43347 | b"couldn't remove %s: %s\n" % (vfs.join(b), inst) | ||
|
r43346 | ) | ||
|
r23249 | self._backupentries = [] | ||
|
r39712 | self._journal = None | ||
|
r26576 | |||
|
r43346 | self._releasefn(self, True) # notify success of closing transaction | ||
self._releasefn = None # Help prevent cycles. | ||||
|
r26576 | |||
|
r23220 | # run post close action | ||
categories = sorted(self._postclosecallback) | ||||
for cat in categories: | ||||
|
r23282 | self._postclosecallback[cat](self) | ||
|
r28960 | # Prevent double usage and help clear cycles. | ||
self._postclosecallback = None | ||||
|
r0 | |||
|
r8289 | @active | ||
|
r0 | def abort(self): | ||
|
r46554 | """abort the transaction (generally called on error, or when the | ||
|
r9220 | transaction is not explicitly committed before going out of | ||
|
r46554 | scope)""" | ||
|
r8289 | self._abort() | ||
|
r23904 | def _writeundo(self): | ||
"""write transaction data for possible future undo call""" | ||||
|
r39711 | if self._undoname is None: | ||
|
r23904 | return | ||
|
r43346 | undobackupfile = self._opener.open( | ||
|
r43347 | b"%s.backupfiles" % self._undoname, b'w' | ||
|
r43346 | ) | ||
|
r43347 | undobackupfile.write(b'%d\n' % version) | ||
|
r23904 | for l, f, b, c in self._backupentries: | ||
if not f: # temporary file | ||||
continue | ||||
if not b: | ||||
|
r43347 | u = b'' | ||
|
r23904 | else: | ||
if l not in self._vfsmap and c: | ||||
|
r43346 | self._report( | ||
|
r43347 | b"couldn't remove %s: unknown cache location" | ||
b"%s\n" % (b, l) | ||||
|
r43346 | ) | ||
|
r23904 | continue | ||
vfs = self._vfsmap[l] | ||||
base, name = vfs.split(b) | ||||
|
r39712 | assert name.startswith(self._journal), name | ||
uname = name.replace(self._journal, self._undoname, 1) | ||||
|
r23904 | u = vfs.reljoin(base, uname) | ||
util.copyfile(vfs.join(b), vfs.join(u), hardlink=True) | ||||
|
r43347 | undobackupfile.write(b"%s\0%s\0%s\0%d\n" % (l, f, u, c)) | ||
|
r23904 | undobackupfile.close() | ||
|
r8289 | def _abort(self): | ||
|
r46483 | entries = self.readjournal() | ||
|
r39710 | self._count = 0 | ||
self._usages = 0 | ||||
|
r39713 | self._file.close() | ||
|
r23249 | self._backupsfile.close() | ||
|
r8290 | |||
|
r10228 | try: | ||
|
r46484 | if not entries and not self._backupentries: | ||
|
r26753 | if self._backupjournal: | ||
|
r39718 | self._opener.unlink(self._backupjournal) | ||
|
r39712 | if self._journal: | ||
|
r39718 | self._opener.unlink(self._journal) | ||
|
r10228 | return | ||
|
r0 | |||
|
r43347 | self._report(_(b"transaction abort!\n")) | ||
|
r0 | |||
|
r108 | try: | ||
|
r23764 | for cat in sorted(self._abortcallback): | ||
self._abortcallback[cat](self) | ||||
|
r28960 | # Prevent double usage and help clear cycles. | ||
self._abortcallback = None | ||||
|
r43346 | _playback( | ||
self._journal, | ||||
self._report, | ||||
self._opener, | ||||
self._vfsmap, | ||||
|
r46483 | entries, | ||
|
r43346 | self._backupentries, | ||
False, | ||||
checkambigfiles=self._checkambigfiles, | ||||
) | ||||
|
r43347 | self._report(_(b"rollback completed\n")) | ||
|
r40614 | except BaseException as exc: | ||
|
r43347 | self._report(_(b"rollback failed - please run hg recover\n")) | ||
|
r43346 | self._report( | ||
|
r43347 | _(b"(failure reason: %s)\n") % stringutil.forcebytestr(exc) | ||
|
r43346 | ) | ||
|
r8294 | finally: | ||
|
r39712 | self._journal = None | ||
|
r43346 | self._releasefn(self, False) # notify failure of transaction | ||
self._releasefn = None # Help prevent cycles. | ||||
|
r8290 | |||
|
r33278 | def rollback(opener, vfsmap, file, report, checkambigfiles=None): | ||
|
r20882 | """Rolls back the transaction contained in the given file | ||
Reads the entries in the specified file, and the corresponding | ||||
'*.backupfiles' file, to recover from an incomplete transaction. | ||||
* `file`: a file containing a list of entries, specifying where | ||||
to truncate each file. The file should contain a list of | ||||
file\0offset pairs, delimited by newlines. The corresponding | ||||
'*.backupfiles' file should contain a list of file\0backupfile | ||||
pairs, delimited by \0. | ||||
|
r33278 | |||
`checkambigfiles` is a set of (path, vfs-location) tuples, | ||||
which determine whether file stat ambiguity should be avoided at | ||||
restoring corresponded files. | ||||
|
r20882 | """ | ||
|
r8294 | entries = [] | ||
|
r20882 | backupentries = [] | ||
|
r8294 | |||
|
r20087 | fp = opener.open(file) | ||
|
r13400 | lines = fp.readlines() | ||
fp.close() | ||||
for l in lines: | ||||
|
r20524 | try: | ||
|
r43347 | f, o = l.split(b'\0') | ||
|
r46481 | entries.append((f, int(o))) | ||
|
r20524 | except ValueError: | ||
|
r43347 | report( | ||
_(b"couldn't read journal entry %r!\n") % pycompat.bytestr(l) | ||||
) | ||||
|
r0 | |||
|
r43347 | backupjournal = b"%s.backupfiles" % file | ||
|
r20882 | if opener.exists(backupjournal): | ||
fp = opener.open(backupjournal) | ||||
|
r23065 | lines = fp.readlines() | ||
if lines: | ||||
ver = lines[0][:-1] | ||||
|
r35850 | if ver == (b'%d' % version): | ||
|
r23065 | for line in lines[1:]: | ||
if line: | ||||
# Shave off the trailing newline | ||||
line = line[:-1] | ||||
|
r43347 | l, f, b, c = line.split(b'\0') | ||
|
r23309 | backupentries.append((l, f, b, bool(c))) | ||
|
r23064 | else: | ||
|
r43346 | report( | ||
_( | ||||
|
r43347 | b"journal was created by a different version of " | ||
b"Mercurial\n" | ||||
|
r43346 | ) | ||
) | ||||
|
r20882 | |||
|
r43346 | _playback( | ||
file, | ||||
report, | ||||
opener, | ||||
vfsmap, | ||||
entries, | ||||
backupentries, | ||||
checkambigfiles=checkambigfiles, | ||||
) | ||||