This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2758

transaction: add a name and a __repr__ implementation (API)
ClosedPublic

Authored by martinvonz on Mar 9 2018, 1:38 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGaff5996f3043: transaction: add a name and a __repr__ implementation (API)
rHG6b1d0cf8a102: transaction: add a name and a __repr__ implementation (API)
rHG49e2ca27c10e: transaction: add a name and a __str__ implementation (API)
Summary

This has been useful for me for debugging.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

martinvonz created this revision.Mar 9 2018, 1:38 PM
durin42 added a subscriber: durin42.Mar 9 2018, 5:20 PM

Either way, you should make sure this always returns a sysstr, otherwise you'll cause pretty terrible python3 breakage. Look around for other repr instances for examples.

mercurial/transaction.py
191

nit: I think this would make more sense as a repr than a str.

martinvonz marked an inline comment as done.Mar 9 2018, 5:28 PM
martinvonz updated this revision to Diff 6790.
martinvonz updated this revision to Diff 6791.Mar 9 2018, 5:29 PM
durin42 accepted this revision.Mar 9 2018, 5:30 PM
This revision is now accepted and ready to land.Mar 9 2018, 5:30 PM
martinvonz retitled this revision from transaction: add a name and a __str__ implementation (API) to transaction: add a name and a __repr__ implementation (API).Mar 9 2018, 5:30 PM
Closed by commit rHG49e2ca27c10e: transaction: add a name and a __str__ implementation (API) (authored by martinvonz). · Explain WhyMar 9 2018, 5:31 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/localrepo.py (5 lines)
Mmercurial/transaction.py (14 lines)

Diff 6790

mercurial/localrepo.py

def transaction(self, desc, report=None): def transaction(self, desc, report=None):
if (self.ui.configbool('devel', 'all-warnings') if (self.ui.configbool('devel', 'all-warnings')
or self.ui.configbool('devel', 'check-locks')): or self.ui.configbool('devel', 'check-locks')):
if self._currentlock(self._lockref) is None: if self._currentlock(self._lockref) is None:
raise error.ProgrammingError('transaction requires locking') raise error.ProgrammingError('transaction requires locking')
tr = self.currenttransaction() tr = self.currenttransaction()
if tr is not None: if tr is not None:
return tr.nest() return tr.nest(name=desc)
# abort here if the journal already exists # abort here if the journal already exists
if self.svfs.exists("journal"): if self.svfs.exists("journal"):
raise error.RepoError( raise error.RepoError(
_("abandoned transaction found"), _("abandoned transaction found"),
hint=_("run 'hg recover' to clean up transaction")) hint=_("run 'hg recover' to clean up transaction"))
idbase = "%.40f#%f" % (random.random(), time.time()) idbase = "%.40f#%f" % (random.random(), time.time())
tr = transaction.transaction(rp, self.svfs, vfsmap, tr = transaction.transaction(rp, self.svfs, vfsmap,
"journal", "journal",
"undo", "undo",
aftertrans(renames), aftertrans(renames),
self.store.createmode, self.store.createmode,
validator=validate, validator=validate,
releasefn=releasefn, releasefn=releasefn,
checkambigfiles=_cachedfiles) checkambigfiles=_cachedfiles,
name=desc)
tr.changes['revs'] = xrange(0, 0) tr.changes['revs'] = xrange(0, 0)
tr.changes['obsmarkers'] = set() tr.changes['obsmarkers'] = set()
tr.changes['phases'] = {} tr.changes['phases'] = {}
tr.changes['bookmarks'] = {} tr.changes['bookmarks'] = {}
tr.hookargs['txnid'] = txnid tr.hookargs['txnid'] = txnid
# note: writing the fncache only during finalize mean that the file is # note: writing the fncache only during finalize mean that the file is
# outdated when running hooks. As fncache is used for streaming clone, # outdated when running hooks. As fncache is used for streaming clone,

mercurial/transaction.py

opener.unlink(f) opener.unlink(f)
except (IOError, OSError, error.Abort) as inst: except (IOError, OSError, error.Abort) as inst:
# only pure backup file remains, it is sage to ignore any error # only pure backup file remains, it is sage to ignore any error
pass pass
class transaction(util.transactional): class transaction(util.transactional):
def __init__(self, report, opener, vfsmap, journalname, undoname=None, def __init__(self, report, opener, vfsmap, journalname, undoname=None,
after=None, createmode=None, validator=None, releasefn=None, after=None, createmode=None, validator=None, releasefn=None,
checkambigfiles=None): checkambigfiles=None, name='<unnamed>'):
"""Begin a new transaction """Begin a new transaction
Begins a new transaction that allows rolling back writes in the event of Begins a new transaction that allows rolling back writes in the event of
an exception. an exception.
* `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)
if releasefn is None: if releasefn is None:
releasefn = lambda tr, success: None releasefn = lambda tr, success: None
self.releasefn = releasefn self.releasefn = releasefn
self.checkambigfiles = set() self.checkambigfiles = set()
if checkambigfiles: if checkambigfiles:
self.checkambigfiles.update(checkambigfiles) self.checkambigfiles.update(checkambigfiles)
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")
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):
durin42Unsubmitted
Done

nit: I think this would make more sense as a repr than a str.

durin42: nit: I think this would make more sense as a __repr__ than a __str__.
name = r'/'.join(self.names)
return (r'<transaction name=%s, count=%d, usages=%d>' %
(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
if file not in self.map: if file not in self.map:
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): def nest(self, name='<unnamed>'):
self.count += 1 self.count += 1
self.usages += 1 self.usages += 1
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:
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):