( )⚙ D4622 transaction: make count and usages private attributes

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4622

transaction: make count and usages private attributes
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG3e8952c0cb45: transaction: make count and usages private attributes
Summary

I want to formalize the interface for transactions. As part of
doing that, let's take the opportunity to make some attributes
non-public.

"count" and "usages" track how many times the transaction has
been opened/nested/closed/released. This is internal state and
doesn't need to be part of the public API.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Sep 17 2018, 7:36 PM
Closed by commit rHG3e8952c0cb45: transaction: make count and usages private attributes (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 11121

mercurial/transaction.py

} }
gengroupall='all' gengroupall='all'
gengroupprefinalize='prefinalize' gengroupprefinalize='prefinalize'
gengrouppostfinalize='postfinalize' gengrouppostfinalize='postfinalize'
def active(func): def active(func):
def _active(self, *args, **kwds): def _active(self, *args, **kwds):
if self.count == 0: if self._count == 0:
raise error.Abort(_( raise error.Abort(_(
'cannot use transaction when it is already committed/aborted')) 'cannot use transaction when it is already committed/aborted'))
return func(self, *args, **kwds) return func(self, *args, **kwds)
return _active return _active
def _playback(journal, report, opener, vfsmap, entries, backupentries, def _playback(journal, report, opener, vfsmap, entries, backupentries,
unlink=True, checkambigfiles=None): unlink=True, checkambigfiles=None):
for f, o, _ignore in entries: for f, o, _ignore in entries:
* `after`: called after the transaction has been committed * `after`: called after the transaction has been committed
* `createmode`: the mode of the journal file that will be created * `createmode`: the mode of the journal file that will be created
* `releasefn`: called after releasing (with transaction and result) * `releasefn`: called after releasing (with transaction and result)
`checkambigfiles` is a set of (path, vfs-location) tuples, `checkambigfiles` is a set of (path, vfs-location) tuples,
which determine whether file stat ambiguity should be avoided which determine whether file stat ambiguity should be avoided
for corresponded files. for corresponded files.
""" """
self.count = 1 self._count = 1
self.usages = 1 self._usages = 1
self.report = report self.report = report
# a vfs to the store content # a vfs to the store content
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
# 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
raise KeyError(file) raise KeyError(file)
index = self.map[file] index = self.map[file]
self.entries[index] = (file, offset, data) self.entries[index] = (file, offset, data)
self.file.write("%s\0%d\n" % (file, offset)) self.file.write("%s\0%d\n" % (file, offset))
self.file.flush() self.file.flush()
@active @active
def nest(self, name=r'<unnamed>'): def nest(self, name=r'<unnamed>'):
self.count += 1 self._count += 1
self.usages += 1 self._usages += 1
self.names.append(name) self.names.append(name)
return self return self
def release(self): def release(self):
if self.count > 0: if self._count > 0:
self.usages -= 1 self._usages -= 1
if self.names: if self.names:
self.names.pop() self.names.pop()
# if the transaction scopes are left without being closed, fail # if the transaction scopes are left without being closed, fail
if self.count > 0 and self.usages == 0: if self._count > 0 and self._usages == 0:
self._abort() self._abort()
def running(self): def running(self):
return self.count > 0 return self._count > 0
def addpending(self, category, callback): def addpending(self, category, callback):
"""add a callback to be called when the transaction is pending """add a callback to be called when the transaction is pending
The transaction will be given as callback's first argument. The transaction will be given as callback's first argument.
Category is a unique identifier to allow overwriting an old callback Category is a unique identifier to allow overwriting an old callback
with a newer callback. with a newer callback.
Category is a unique identifier to allow overwriting an old callback Category is a unique identifier to allow overwriting an old callback
with a newer callback. with a newer callback.
""" """
self._abortcallback[category] = callback self._abortcallback[category] = callback
@active @active
def close(self): def close(self):
'''commit the transaction''' '''commit the transaction'''
if self.count == 1: if self._count == 1:
self.validator(self) # will raise exception if needed self.validator(self) # will raise exception if needed
self.validator = None # Help prevent cycles. self.validator = None # Help prevent cycles.
self._generatefiles(group=gengroupprefinalize) self._generatefiles(group=gengroupprefinalize)
categories = sorted(self._finalizecallback) categories = sorted(self._finalizecallback)
for cat in categories: for cat in categories:
self._finalizecallback[cat](self) self._finalizecallback[cat](self)
# Prevent double usage and help clear cycles. # Prevent double usage and help clear cycles.
self._finalizecallback = None self._finalizecallback = None
self._generatefiles(group=gengrouppostfinalize) self._generatefiles(group=gengrouppostfinalize)
self.count -= 1 self._count -= 1
if self.count != 0: if self._count != 0:
return return
self.file.close() self.file.close()
self._backupsfile.close() self._backupsfile.close()
# cleanup temporary files # cleanup temporary files
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 %s\n" self.report("couldn't remove %s: unknown cache location %s\n"
% (b, l)) % (b, l))
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: