( )⚙ D4624 transaction: make journal a private attribute

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4624

transaction: make journal a private attribute
ClosedPublic

Authored by indygreg on Sep 17 2018, 7:36 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG77c4e2ae9f07: transaction: make journal a private attribute
Summary

This attribute tracks the name of the journal file. It is an
implementation detail of the current transaction and therefore
shouldn't be exposed as part of the interface. Let's mark it as
private.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

indygreg created this revision.Sep 17 2018, 7:36 PM
Closed by commit rHG77c4e2ae9f07: transaction: make journal a private attribute (authored by indygreg). · Explain WhySep 18 2018, 5:28 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/transaction.py (30 lines)

Diff 11150

mercurial/transaction.py

self.opener = opener self.opener = opener
# a map to access file in various {location -> vfs} # a map to access file in various {location -> vfs}
vfsmap = vfsmap.copy() vfsmap = vfsmap.copy()
vfsmap[''] = opener # set default value vfsmap[''] = opener # set default value
self._vfsmap = vfsmap self._vfsmap = vfsmap
self.after = after self.after = after
self.entries = [] self.entries = []
self.map = {} self.map = {}
self.journal = journalname self._journal = journalname
self._undoname = undoname self._undoname = undoname
self._queue = [] self._queue = []
# A callback to validate transaction content before closing it. # A callback to validate transaction content before closing it.
# should raise exception is anything is wrong. # should raise exception is anything is wrong.
# target user is repository hooks. # target user is repository hooks.
if validator is None: if validator is None:
validator = lambda tr: None validator = lambda tr: None
self.validator = validator self.validator = validator
self.names = [name] self.names = [name]
# A dict dedicated to precisely tracking the changes introduced in the # A dict dedicated to precisely tracking the changes introduced in the
# transaction. # transaction.
self.changes = {} self.changes = {}
# a dict of arguments to be passed to hooks # a dict of arguments to be passed to hooks
self.hookargs = {} self.hookargs = {}
self.file = opener.open(self.journal, "w") self.file = opener.open(self._journal, "w")
# a list of ('location', 'path', 'backuppath', cache) entries. # a list of ('location', 'path', 'backuppath', cache) entries.
# - if 'backuppath' is empty, no file existed at backup time # - if 'backuppath' is empty, no file existed at backup time
# - if 'path' is empty, this is a temporary transaction file # - if 'path' is empty, this is a temporary transaction file
# - if 'location' is not empty, the path is outside main opener reach. # - 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' # use 'location' value as a key in a vfsmap to find the right 'vfs'
# (cache is currently unused) # (cache is currently unused)
self._backupentries = [] self._backupentries = []
self._backupmap = {} self._backupmap = {}
self._backupjournal = "%s.backupfiles" % self.journal self._backupjournal = "%s.backupfiles" % self._journal
self._backupsfile = opener.open(self._backupjournal, 'w') self._backupsfile = opener.open(self._backupjournal, 'w')
self._backupsfile.write('%d\n' % version) self._backupsfile.write('%d\n' % version)
if createmode is not None: if createmode is not None:
opener.chmod(self.journal, createmode & 0o666) opener.chmod(self._journal, createmode & 0o666)
opener.chmod(self._backupjournal, createmode & 0o666) opener.chmod(self._backupjournal, createmode & 0o666)
# hold file generations to be performed on commit # hold file generations to be performed on commit
self._filegenerators = {} self._filegenerators = {}
# hold callback to write pending data for hooks # hold callback to write pending data for hooks
self._pendingcallback = {} self._pendingcallback = {}
# True is any pending data have been written ever # True is any pending data have been written ever
self._anypending = False self._anypending = False
# holds callback to call when writing the transaction # holds callback to call when writing the transaction
self._finalizecallback = {} self._finalizecallback = {}
# hold callback for post transaction close # hold callback for post transaction close
self._postclosecallback = {} self._postclosecallback = {}
# holds callbacks to call during abort # holds callbacks to call during abort
self._abortcallback = {} self._abortcallback = {}
def __repr__(self): def __repr__(self):
name = r'/'.join(self.names) name = r'/'.join(self.names)
return (r'<transaction name=%s, count=%d, usages=%d>' % return (r'<transaction name=%s, count=%d, usages=%d>' %
(name, self._count, self._usages)) (name, self._count, self._usages))
def __del__(self): def __del__(self):
if self.journal: if self._journal:
self._abort() self._abort()
@active @active
def startgroup(self): def startgroup(self):
"""delay registration of file entry """delay registration of file entry
This is used by strip to delay vision of strip offset. The transaction 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.""" sees either none or all of the strip actions to be done."""
if self._queue: if self._queue:
msg = 'cannot use transaction.addbackup inside "group"' msg = 'cannot use transaction.addbackup inside "group"'
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
if file in self.map or file in self._backupmap: if file in self.map or file in self._backupmap:
return return
vfs = self._vfsmap[location] vfs = self._vfsmap[location]
dirname, filename = vfs.split(file) dirname, filename = vfs.split(file)
backupfilename = "%s.backup.%s" % (self.journal, filename) backupfilename = "%s.backup.%s" % (self._journal, filename)
backupfile = vfs.reljoin(dirname, backupfilename) backupfile = vfs.reljoin(dirname, backupfilename)
if vfs.exists(file): if vfs.exists(file):
filepath = vfs.join(file) filepath = vfs.join(file)
backuppath = vfs.join(backupfile) backuppath = vfs.join(backupfile)
util.copyfile(filepath, backuppath, hardlink=hardlink) util.copyfile(filepath, backuppath, hardlink=hardlink)
else: else:
backupfile = '' backupfile = ''
% (vfs.join(b), inst)) % (vfs.join(b), inst))
self.entries = [] self.entries = []
self._writeundo() self._writeundo()
if self.after: if self.after:
self.after() self.after()
self.after = None # Help prevent cycles. self.after = None # Help prevent cycles.
if self.opener.isfile(self._backupjournal): if self.opener.isfile(self._backupjournal):
self.opener.unlink(self._backupjournal) self.opener.unlink(self._backupjournal)
if self.opener.isfile(self.journal): if self.opener.isfile(self._journal):
self.opener.unlink(self.journal) self.opener.unlink(self._journal)
for l, _f, b, c in self._backupentries: for l, _f, b, c in self._backupentries:
if l not in self._vfsmap and c: if l not in self._vfsmap and c:
self.report("couldn't remove %s: unknown cache location" self.report("couldn't remove %s: unknown cache location"
"%s\n" % (b, l)) "%s\n" % (b, l))
continue continue
vfs = self._vfsmap[l] vfs = self._vfsmap[l]
if b and vfs.exists(b): if b and vfs.exists(b):
try: try:
vfs.unlink(b) vfs.unlink(b)
except (IOError, OSError, error.Abort) as inst: except (IOError, OSError, error.Abort) as inst:
if not c: if not c:
raise raise
# Abort may be raise by read only opener # Abort may be raise by read only opener
self.report("couldn't remove %s: %s\n" self.report("couldn't remove %s: %s\n"
% (vfs.join(b), inst)) % (vfs.join(b), inst))
self._backupentries = [] self._backupentries = []
self.journal = None self._journal = None
self.releasefn(self, True) # notify success of closing transaction self.releasefn(self, True) # notify success of closing transaction
self.releasefn = None # Help prevent cycles. self.releasefn = None # Help prevent cycles.
# run post close action # run post close action
categories = sorted(self._postclosecallback) categories = sorted(self._postclosecallback)
for cat in categories: for cat in categories:
self._postclosecallback[cat](self) self._postclosecallback[cat](self)
u = '' u = ''
else: else:
if l not in self._vfsmap and c: if l not in self._vfsmap and c:
self.report("couldn't remove %s: unknown cache location" self.report("couldn't remove %s: unknown cache location"
"%s\n" % (b, l)) "%s\n" % (b, l))
continue continue
vfs = self._vfsmap[l] vfs = self._vfsmap[l]
base, name = vfs.split(b) base, name = vfs.split(b)
assert name.startswith(self.journal), name assert name.startswith(self._journal), name
uname = name.replace(self.journal, self._undoname, 1) uname = name.replace(self._journal, self._undoname, 1)
u = vfs.reljoin(base, uname) u = vfs.reljoin(base, uname)
util.copyfile(vfs.join(b), vfs.join(u), hardlink=True) util.copyfile(vfs.join(b), vfs.join(u), hardlink=True)
undobackupfile.write("%s\0%s\0%s\0%d\n" % (l, f, u, c)) undobackupfile.write("%s\0%s\0%s\0%d\n" % (l, f, u, c))
undobackupfile.close() undobackupfile.close()
def _abort(self): def _abort(self):
self._count = 0 self._count = 0
self._usages = 0 self._usages = 0
self.file.close() self.file.close()
self._backupsfile.close() self._backupsfile.close()
try: try:
if not self.entries and not self._backupentries: if not self.entries and not self._backupentries:
if self._backupjournal: if self._backupjournal:
self.opener.unlink(self._backupjournal) self.opener.unlink(self._backupjournal)
if self.journal: if self._journal:
self.opener.unlink(self.journal) self.opener.unlink(self._journal)
return return
self.report(_("transaction abort!\n")) self.report(_("transaction abort!\n"))
try: try:
for cat in sorted(self._abortcallback): for cat in sorted(self._abortcallback):
self._abortcallback[cat](self) self._abortcallback[cat](self)
# Prevent double usage and help clear cycles. # Prevent double usage and help clear cycles.
self._abortcallback = None self._abortcallback = None
_playback(self.journal, self.report, self.opener, self._vfsmap, _playback(self._journal, self.report, self.opener, self._vfsmap,
self.entries, self._backupentries, False, self.entries, self._backupentries, False,
checkambigfiles=self.checkambigfiles) checkambigfiles=self.checkambigfiles)
self.report(_("rollback completed\n")) self.report(_("rollback completed\n"))
except BaseException: except BaseException:
self.report(_("rollback failed - please run hg recover\n")) self.report(_("rollback failed - please run hg recover\n"))
finally: finally:
self.journal = None self._journal = None
self.releasefn(self, False) # notify failure of transaction self.releasefn(self, False) # notify failure of transaction
self.releasefn = None # Help prevent cycles. self.releasefn = None # Help prevent cycles.
def rollback(opener, vfsmap, file, report, checkambigfiles=None): def rollback(opener, vfsmap, file, report, checkambigfiles=None):
"""Rolls back the transaction contained in the given file """Rolls back the transaction contained in the given file
Reads the entries in the specified file, and the corresponding Reads the entries in the specified file, and the corresponding
'*.backupfiles' file, to recover from an incomplete transaction. '*.backupfiles' file, to recover from an incomplete transaction.