Mercurial > hg
view mercurial/transaction.py @ 19929:ab2362e1672e
merge: exit early during a no-op update (BC)
hg update . (or equivalents) are effectively no-ops in just about all
circumstances. These sorts of updates can be especially common in a
bookmark-oriented workflow. This saves us a status check and a manifest
decompression, which means that on a repo with over 210,000 files, this brings
hg update . down from 2.5 seconds to 0.15.
There is one change in behavior: a file that was added, not committed, and then
deleted but not removed used to be removed from the dirstate. With this patch
it isn't. This is what causes the change in test-mq-qpush-exact.t. This seems
like it's enough of an edge case to not be worth handling.
The output of test-empty.t changes because those files are not yet created.
author | Siddharth Agarwal <sid0@fb.com> |
---|---|
date | Tue, 01 Oct 2013 17:43:54 -0700 |
parents | e7cfe3587ea4 |
children | a3378a1b0a05 |
line wrap: on
line source
# transaction.py - simple journaling scheme for mercurial # # 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. # # Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> # # This software may be used and distributed according to the terms of the # GNU General Public License version 2 or any later version. from i18n import _ import os, errno import error, util def active(func): def _active(self, *args, **kwds): if self.count == 0: raise error.Abort(_( 'cannot use transaction when it is already committed/aborted')) return func(self, *args, **kwds) return _active def _playback(journal, report, opener, entries, unlink=True): for f, o, ignore in entries: if o or not unlink: try: fp = opener(f, 'a') fp.truncate(o) fp.close() except IOError: report(_("failed to truncate %s\n") % f) raise else: try: fp = opener(f) fn = fp.name fp.close() util.unlink(fn) except (IOError, OSError), inst: if inst.errno != errno.ENOENT: raise util.unlink(journal) class transaction(object): def __init__(self, report, opener, journal, after=None, createmode=None): self.count = 1 self.usages = 1 self.report = report self.opener = opener self.after = after self.entries = [] self.map = {} self.journal = journal self._queue = [] self.file = util.posixfile(self.journal, "w") if createmode is not None: os.chmod(self.journal, createmode & 0666) def __del__(self): if self.journal: self._abort() @active def startgroup(self): self._queue.append([]) @active def endgroup(self): q = self._queue.pop() d = ''.join(['%s\0%d\n' % (x[0], x[1]) for x in q]) self.entries.extend(q) self.file.write(d) self.file.flush() @active def add(self, file, offset, data=None): if file in self.map: return if self._queue: self._queue[-1].append((file, offset, data)) return self.entries.append((file, offset, data)) self.map[file] = len(self.entries) - 1 # add enough data to the journal to do the truncate self.file.write("%s\0%d\n" % (file, offset)) self.file.flush() @active def find(self, file): if file in self.map: return self.entries[self.map[file]] return None @active def replace(self, file, offset, data=None): ''' replace can only replace already committed entries that are not pending in the queue ''' if file not in self.map: raise KeyError(file) index = self.map[file] self.entries[index] = (file, offset, data) self.file.write("%s\0%d\n" % (file, offset)) self.file.flush() @active def nest(self): self.count += 1 self.usages += 1 return self def release(self): if self.count > 0: self.usages -= 1 # if the transaction scopes are left without being closed, fail if self.count > 0 and self.usages == 0: self._abort() def running(self): return self.count > 0 @active def close(self): '''commit the transaction''' self.count -= 1 if self.count != 0: return self.file.close() self.entries = [] if self.after: self.after() if os.path.isfile(self.journal): util.unlink(self.journal) self.journal = None @active def abort(self): '''abort the transaction (generally called on error, or when the transaction is not explicitly committed before going out of scope)''' self._abort() def _abort(self): self.count = 0 self.usages = 0 self.file.close() try: if not self.entries: if self.journal: util.unlink(self.journal) return self.report(_("transaction abort!\n")) try: _playback(self.journal, self.report, self.opener, self.entries, False) self.report(_("rollback completed\n")) except Exception: self.report(_("rollback failed - please run hg recover\n")) finally: self.journal = None def rollback(opener, file, report): entries = [] fp = util.posixfile(file) lines = fp.readlines() fp.close() for l in lines: f, o = l.split('\0') entries.append((f, int(o), None)) _playback(file, report, opener, entries)