mercurial: comparison mercurial/localrepo.py

equal deleted inserted replaced

-:9a2a73ea6135
+:97b734fb9c6f
 self.transhandle = tr
 return tr
 def recover(self):
 l = self.lock()
-if os.path.exists(self.sjoin("journal")):
+try:
-self.ui.status(_("rolling back interrupted transaction\n"))
+if os.path.exists(self.sjoin("journal")):
-transaction.rollback(self.sopener, self.sjoin("journal"))
+self.ui.status(_("rolling back interrupted transaction\n"))
-self.invalidate()
+transaction.rollback(self.sopener, self.sjoin("journal"))
-return True
+self.invalidate()
-else:
+return True
-self.ui.warn(_("no interrupted transaction available\n"))
+else:
-return False
+self.ui.warn(_("no interrupted transaction available\n"))
+return False
+finally:
+del l
 def rollback(self, wlock=None, lock=None):
-if not wlock:
+try:
-wlock = self.wlock()
+if not wlock:
-if not lock:
+wlock = self.wlock()
-lock = self.lock()
+if not lock:
-if os.path.exists(self.sjoin("undo")):
+lock = self.lock()
-self.ui.status(_("rolling back last transaction\n"))
+if os.path.exists(self.sjoin("undo")):
-transaction.rollback(self.sopener, self.sjoin("undo"))
+self.ui.status(_("rolling back last transaction\n"))
-util.rename(self.join("undo.dirstate"), self.join("dirstate"))
+transaction.rollback(self.sopener, self.sjoin("undo"))
-self.invalidate()
+util.rename(self.join("undo.dirstate"), self.join("dirstate"))
-self.dirstate.invalidate()
+self.invalidate()
-else:
+self.dirstate.invalidate()
-self.ui.warn(_("no rollback information available\n"))
+else:
+self.ui.warn(_("no rollback information available\n"))
+finally:
+del wlock, lock
 def invalidate(self):
 for a in "changelog manifest".split():
 if hasattr(self, a):
 self.__delattr__(a)
 p1=p1, p2=p2, wlock=wlock, extra=extra)
 def commit(self, files=None, text="", user=None, date=None,
 match=util.always, force=False, lock=None, wlock=None,
 force_editor=False, p1=None, p2=None, extra={}):
+tr = None
-commit = []
+try:
-remove = []
+commit = []
-changed = []
+remove = []
-use_dirstate = (p1 is None) # not rawcommit
+changed = []
-extra = extra.copy()
+use_dirstate = (p1 is None) # not rawcommit
+extra = extra.copy()
-if use_dirstate:
-if files:
+if use_dirstate:
-for f in files:
+if files:
-s = self.dirstate[f]
+for f in files:
-if s in 'nma':
+s = self.dirstate[f]
-commit.append(f)
+if s in 'nma':
-elif s == 'r':
+commit.append(f)
+elif s == 'r':
+remove.append(f)
+else:
+self.ui.warn(_("%s not tracked!\n") % f)
+else:
+changes = self.status(match=match)[:5]
+modified, added, removed, deleted, unknown = changes
+commit = modified + added
+remove = removed
+else:
+commit = files
+if use_dirstate:
+p1, p2 = self.dirstate.parents()
+update_dirstate = True
+else:
+p1, p2 = p1, p2 or nullid
+update_dirstate = (self.dirstate.parents()[0] == p1)
+c1 = self.changelog.read(p1)
+c2 = self.changelog.read(p2)
+m1 = self.manifest.read(c1[0]).copy()
+m2 = self.manifest.read(c2[0])
+if use_dirstate:
+branchname = self.workingctx().branch()
+try:
+branchname = branchname.decode('UTF-8').encode('UTF-8')
+except UnicodeDecodeError:
+raise util.Abort(_('branch name not in UTF-8!'))
+else:
+branchname = ""
+if use_dirstate:
+oldname = c1[5].get("branch") # stored in UTF-8
+if (not commit and not remove and not force and p2 == nullid
+and branchname == oldname):
+self.ui.status(_("nothing changed\n"))
+return None
+xp1 = hex(p1)
+if p2 == nullid: xp2 = ''
+else: xp2 = hex(p2)
+self.hook("precommit", throw=True, parent1=xp1, parent2=xp2)
+if not wlock:
+wlock = self.wlock()
+if not lock:
+lock = self.lock()
+tr = self.transaction()
+# check in files
+new = {}
+linkrev = self.changelog.count()
+commit.sort()
+is_exec = util.execfunc(self.root, m1.execf)
+is_link = util.linkfunc(self.root, m1.linkf)
+for f in commit:
+self.ui.note(f + "\n")
+try:
+new[f] = self.filecommit(f, m1, m2, linkrev, tr, changed)
+new_exec = is_exec(f)
+new_link = is_link(f)
+if not changed or changed[-1] != f:
+# mention the file in the changelog if some
+# flag changed, even if there was no content
+# change.
+old_exec = m1.execf(f)
+old_link = m1.linkf(f)
+if old_exec != new_exec or old_link != new_link:
+changed.append(f)
+m1.set(f, new_exec, new_link)
+except (OSError, IOError):
+if use_dirstate:
+self.ui.warn(_("trouble committing %s!\n") % f)
+raise
+else:
 remove.append(f)
-else:
-self.ui.warn(_("%s not tracked!\n") % f)
+# update manifest
-else:
+m1.update(new)
-changes = self.status(match=match)[:5]
+remove.sort()
-modified, added, removed, deleted, unknown = changes
+removed = []
-commit = modified + added
-remove = removed
+for f in remove:
-else:
+if f in m1:
-commit = files
+del m1[f]
+removed.append(f)
-if use_dirstate:
+elif f in m2:
-p1, p2 = self.dirstate.parents()
+removed.append(f)
-update_dirstate = True
+mn = self.manifest.add(m1, tr, linkrev, c1[0], c2[0],
-else:
+(new, removed))
-p1, p2 = p1, p2 or nullid
-update_dirstate = (self.dirstate.parents()[0] == p1)
+# add changeset
+new = new.keys()
-c1 = self.changelog.read(p1)
+new.sort()
-c2 = self.changelog.read(p2)
-m1 = self.manifest.read(c1[0]).copy()
+user = user or self.ui.username()
-m2 = self.manifest.read(c2[0])
+if not text or force_editor:
+edittext = []
-if use_dirstate:
+if text:
-branchname = self.workingctx().branch()
+edittext.append(text)
-try:
+edittext.append("")
-branchname = branchname.decode('UTF-8').encode('UTF-8')
+edittext.append("HG: user: %s" % user)
-except UnicodeDecodeError:
+if p2 != nullid:
-raise util.Abort(_('branch name not in UTF-8!'))
+edittext.append("HG: branch merge")
-else:
+if branchname:
-branchname = ""
+edittext.append("HG: branch %s" % util.tolocal(branchname))
+edittext.extend(["HG: changed %s" % f for f in changed])
-if use_dirstate:
+edittext.extend(["HG: removed %s" % f for f in removed])
-oldname = c1[5].get("branch") # stored in UTF-8
+if not changed and not remove:
-if (not commit and not remove and not force and p2 == nullid
+edittext.append("HG: no files changed")
-and branchname == oldname):
+edittext.append("")
-self.ui.status(_("nothing changed\n"))
+# run editor in the repository root
+olddir = os.getcwd()
+os.chdir(self.root)
+text = self.ui.edit("\n".join(edittext), user)
+os.chdir(olddir)
+lines = [line.rstrip() for line in text.rstrip().splitlines()]
+while lines and not lines[0]:
+del lines[0]
+if not lines:
 return None
+text = '\n'.join(lines)
-xp1 = hex(p1)
+if branchname:
-if p2 == nullid: xp2 = ''
+extra["branch"] = branchname
-else: xp2 = hex(p2)
+n = self.changelog.add(mn, changed + removed, text, tr, p1, p2,
+user, date, extra)
-self.hook("precommit", throw=True, parent1=xp1, parent2=xp2)
+self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
+parent2=xp2)
-if not wlock:
+tr.close()
-wlock = self.wlock()
-if not lock:
+if self.branchcache and "branch" in extra:
-lock = self.lock()
+self.branchcache[util.tolocal(extra["branch"])] = n
-tr = self.transaction()
+if use_dirstate or update_dirstate:
-# check in files
+self.dirstate.setparents(n)
-new = {}
-linkrev = self.changelog.count()
-commit.sort()
-is_exec = util.execfunc(self.root, m1.execf)
-is_link = util.linkfunc(self.root, m1.linkf)
-for f in commit:
-self.ui.note(f + "\n")
-try:
-new[f] = self.filecommit(f, m1, m2, linkrev, tr, changed)
-new_exec = is_exec(f)
-new_link = is_link(f)
-if not changed or changed[-1] != f:
-# mention the file in the changelog if some flag changed,
-# even if there was no content change.
-old_exec = m1.execf(f)
-old_link = m1.linkf(f)
-if old_exec != new_exec or old_link != new_link:
-changed.append(f)
-m1.set(f, new_exec, new_link)
-except (OSError, IOError):
 if use_dirstate:
-self.ui.warn(_("trouble committing %s!\n") % f)
+for f in new:
-raise
+self.dirstate.normal(f)
-else:
+for f in removed:
-remove.append(f)
+self.dirstate.forget(f)
-# update manifest
+self.hook("commit", node=hex(n), parent1=xp1, parent2=xp2)
-m1.update(new)
+return n
-remove.sort()
+finally:
-removed = []
+del lock, wlock, tr
-for f in remove:
-if f in m1:
-del m1[f]
-removed.append(f)
-elif f in m2:
-removed.append(f)
-mn = self.manifest.add(m1, tr, linkrev, c1[0], c2[0], (new, removed))
-# add changeset
-new = new.keys()
-new.sort()
-user = user or self.ui.username()
-if not text or force_editor:
-edittext = []
-if text:
-edittext.append(text)
-edittext.append("")
-edittext.append("HG: user: %s" % user)
-if p2 != nullid:
-edittext.append("HG: branch merge")
-if branchname:
-edittext.append("HG: branch %s" % util.tolocal(branchname))
-edittext.extend(["HG: changed %s" % f for f in changed])
-edittext.extend(["HG: removed %s" % f for f in removed])
-if not changed and not remove:
-edittext.append("HG: no files changed")
-edittext.append("")
-# run editor in the repository root
-olddir = os.getcwd()
-os.chdir(self.root)
-text = self.ui.edit("\n".join(edittext), user)
-os.chdir(olddir)
-lines = [line.rstrip() for line in text.rstrip().splitlines()]
-while lines and not lines[0]:
-del lines[0]
-if not lines:
-return None
-text = '\n'.join(lines)
-if branchname:
-extra["branch"] = branchname
-n = self.changelog.add(mn, changed + removed, text, tr, p1, p2,
-user, date, extra)
-self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
-parent2=xp2)
-tr.close()
-if self.branchcache and "branch" in extra:
-self.branchcache[util.tolocal(extra["branch"])] = n
-if use_dirstate or update_dirstate:
-self.dirstate.setparents(n)
-if use_dirstate:
-for f in new:
-self.dirstate.normal(f)
-for f in removed:
-self.dirstate.forget(f)
-self.hook("commit", node=hex(n), parent1=xp1, parent2=xp2)
-return n
 def walk(self, node=None, files=[], match=util.always, badmatch=None):
 '''
 walk recursively through the directory tree or a given
 changeset, finding all files matched by the match
 if list_clean:
 clean.append(f)
 # update dirstate for files that are actually clean
 if fixup:
-cleanup = False
+fixlock = wlock
-if not wlock:
+try:
-try:
+if not fixlock:
-wlock = self.wlock(False)
+try:
-cleanup = True
+fixlock = self.wlock(False)
 except lock.LockException:
 pass
-if wlock:
+if fixlock:
 for f in fixup:
 self.dirstate.normal(f)
-if cleanup:
+finally:
-wlock.release()
+del fixlock
 else:
 # we are comparing working dir against non-parent
 # generate a pseudo-manifest for the working dir
 # XXX: create it in dirstate.py ?
 mf2 = mfmatches(self.dirstate.parents()[0])
 for l in modified, added, removed, deleted, unknown, ignored, clean:
 l.sort()
 return (modified, added, removed, deleted, unknown, ignored, clean)
 def add(self, list, wlock=None):
-if not wlock:
+try:
-wlock = self.wlock()
-for f in list:
-p = self.wjoin(f)
-try:
-st = os.lstat(p)
-except:
-self.ui.warn(_("%s does not exist!\n") % f)
-continue
-if st.st_size > 10000000:
-self.ui.warn(_("%s: files over 10MB may cause memory and"
-" performance problems\n"
-"(use 'hg revert %s' to unadd the file)\n")
-% (f, f))
-if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
-self.ui.warn(_("%s not added: only files and symlinks "
-"supported currently\n") % f)
-elif self.dirstate[f] in 'an':
-self.ui.warn(_("%s already tracked!\n") % f)
-else:
-self.dirstate.add(f)
-def forget(self, list, wlock=None):
-if not wlock:
-wlock = self.wlock()
-for f in list:
-if self.dirstate[f] != 'a':
-self.ui.warn(_("%s not added!\n") % f)
-else:
-self.dirstate.forget(f)
-def remove(self, list, unlink=False, wlock=None):
-if unlink:
-for f in list:
-try:
-util.unlink(self.wjoin(f))
-except OSError, inst:
-if inst.errno != errno.ENOENT:
-raise
-if not wlock:
-wlock = self.wlock()
-for f in list:
-if unlink and os.path.exists(self.wjoin(f)):
-self.ui.warn(_("%s still exists!\n") % f)
-elif self.dirstate[f] == 'a':
-self.dirstate.forget(f)
-elif f not in self.dirstate:
-self.ui.warn(_("%s not tracked!\n") % f)
-else:
-self.dirstate.remove(f)
-def undelete(self, list, wlock=None):
-p = self.dirstate.parents()[0]
-mn = self.changelog.read(p)[0]
-m = self.manifest.read(mn)
-if not wlock:
-wlock = self.wlock()
-for f in list:
-if self.dirstate[f] != 'r':
-self.ui.warn("%s not removed!\n" % f)
-else:
-t = self.file(f).read(m[f])
-self.wwrite(f, t, m.flags(f))
-self.dirstate.normal(f)
-def copy(self, source, dest, wlock=None):
-p = self.wjoin(dest)
-if not (os.path.exists(p) or os.path.islink(p)):
-self.ui.warn(_("%s does not exist!\n") % dest)
-elif not (os.path.isfile(p) or os.path.islink(p)):
-self.ui.warn(_("copy failed: %s is not a file or a "
-"symbolic link\n") % dest)
-else:
 if not wlock:
 wlock = self.wlock()
-if dest not in self.dirstate:
+for f in list:
-self.dirstate.add(dest)
+p = self.wjoin(f)
-self.dirstate.copy(source, dest)
+try:
+st = os.lstat(p)
+except:
+self.ui.warn(_("%s does not exist!\n") % f)
+continue
+if st.st_size > 10000000:
+self.ui.warn(_("%s: files over 10MB may cause memory and"
+" performance problems\n"
+"(use 'hg revert %s' to unadd the file)\n")
+% (f, f))
+if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
+self.ui.warn(_("%s not added: only files and symlinks "
+"supported currently\n") % f)
+elif self.dirstate[f] in 'an':
+self.ui.warn(_("%s already tracked!\n") % f)
+else:
+self.dirstate.add(f)
+finally:
+del wlock
+def forget(self, list, wlock=None):
+try:
+if not wlock:
+wlock = self.wlock()
+for f in list:
+if self.dirstate[f] != 'a':
+self.ui.warn(_("%s not added!\n") % f)
+else:
+self.dirstate.forget(f)
+finally:
+del wlock
+def remove(self, list, unlink=False, wlock=None):
+try:
+if unlink:
+for f in list:
+try:
+util.unlink(self.wjoin(f))
+except OSError, inst:
+if inst.errno != errno.ENOENT:
+raise
+if not wlock:
+wlock = self.wlock()
+for f in list:
+if unlink and os.path.exists(self.wjoin(f)):
+self.ui.warn(_("%s still exists!\n") % f)
+elif self.dirstate[f] == 'a':
+self.dirstate.forget(f)
+elif f not in self.dirstate:
+self.ui.warn(_("%s not tracked!\n") % f)
+else:
+self.dirstate.remove(f)
+finally:
+del wlock
+def undelete(self, list, wlock=None):
+try:
+p = self.dirstate.parents()[0]
+mn = self.changelog.read(p)[0]
+m = self.manifest.read(mn)
+if not wlock:
+wlock = self.wlock()
+for f in list:
+if self.dirstate[f] != 'r':
+self.ui.warn("%s not removed!\n" % f)
+else:
+t = self.file(f).read(m[f])
+self.wwrite(f, t, m.flags(f))
+self.dirstate.normal(f)
+finally:
+del wlock
+def copy(self, source, dest, wlock=None):
+try:
+p = self.wjoin(dest)
+if not (os.path.exists(p) or os.path.islink(p)):
+self.ui.warn(_("%s does not exist!\n") % dest)
+elif not (os.path.isfile(p) or os.path.islink(p)):
+self.ui.warn(_("copy failed: %s is not a file or a "
+"symbolic link\n") % dest)
+else:
+if not wlock:
+wlock = self.wlock()
+if dest not in self.dirstate:
+self.dirstate.add(dest)
+self.dirstate.copy(source, dest)
+finally:
+del wlock
 def heads(self, start=None):
 heads = self.changelog.heads(start)
 # sort the output in rev descending order
 heads = [(-self.changelog.rev(h), h) for h in heads]
 return subset, updated_heads.keys()
 else:
 return subset
 def pull(self, remote, heads=None, force=False, lock=None):
-mylock = False
-if not lock:
-lock = self.lock()
-mylock = True
 try:
+if not lock:
+lock = self.lock()
 fetch = self.findincoming(remote, force=force)
 if fetch == [nullid]:
 self.ui.status(_("requesting all changes\n"))
 if not fetch:
 if 'changegroupsubset' not in remote.capabilities:
 raise util.Abort(_("Partial pull cannot be done because other repository doesn't support changegroupsubset."))
 cg = remote.changegroupsubset(fetch, heads, 'pull')
 return self.addchangegroup(cg, 'pull', remote.url())
 finally:
-if mylock:
+del lock
-lock.release()
 def push(self, remote, force=False, revs=None):
 # there are two ways to push to remote repo:
 #
 # addchangegroup assumes local user can lock remote
 cg = self.changegroupsubset(update, revs, 'push')
 return cg, remote_heads
 def push_addchangegroup(self, remote, force, revs):
 lock = remote.lock()
+try:
 ret = self.prepush(remote, force, revs)
 if ret[0] is not None:
 cg, remote_heads = ret
 return remote.addchangegroup(cg, 'push', self.url())
 return ret[1]
+finally:
+del lock
 def push_unbundle(self, remote, force, revs):
 # local repo finds heads on server, finds out what revs it
 # must push.  once revs transferred, if server finds it has
 # different heads (someone else won commit/push race), server
 self.hook('prechangegroup', throw=True, source=srctype, url=url)
 changesets = files = revisions = 0
-tr = self.transaction()
 # write changelog data to temp files so concurrent readers will not see
 # inconsistent view
 cl = self.changelog
 cl.delayupdate()
 oldheads = len(cl.heads())
-# pull off the changeset group
+tr = self.transaction()
-self.ui.status(_("adding changesets\n"))
+try:
-cor = cl.count() - 1
+# pull off the changeset group
-chunkiter = changegroup.chunkiter(source)
+self.ui.status(_("adding changesets\n"))
-if cl.addgroup(chunkiter, csmap, tr, 1) is None:
+cor = cl.count() - 1
-raise util.Abort(_("received changelog group is empty"))
-cnr = cl.count() - 1
-changesets = cnr - cor
-# pull off the manifest group
-self.ui.status(_("adding manifests\n"))
-chunkiter = changegroup.chunkiter(source)
-# no need to check for empty manifest group here:
-# if the result of the merge of 1 and 2 is the same in 3 and 4,
-# no new manifest will be created and the manifest group will
-# be empty during the pull
-self.manifest.addgroup(chunkiter, revmap, tr)
-# process the files
-self.ui.status(_("adding file changes\n"))
-while 1:
-f = changegroup.getchunk(source)
-if not f:
-break
-self.ui.debug(_("adding %s revisions\n") % f)
-fl = self.file(f)
-o = fl.count()
 chunkiter = changegroup.chunkiter(source)
-if fl.addgroup(chunkiter, revmap, tr) is None:
+if cl.addgroup(chunkiter, csmap, tr, 1) is None:
-raise util.Abort(_("received file revlog group is empty"))
+raise util.Abort(_("received changelog group is empty"))
-revisions += fl.count() - o
+cnr = cl.count() - 1
-files += 1
+changesets = cnr - cor
-# make changelog see real files again
+# pull off the manifest group
-cl.finalize(tr)
+self.ui.status(_("adding manifests\n"))
+chunkiter = changegroup.chunkiter(source)
-newheads = len(self.changelog.heads())
+# no need to check for empty manifest group here:
-heads = ""
+# if the result of the merge of 1 and 2 is the same in 3 and 4,
-if oldheads and newheads != oldheads:
+# no new manifest will be created and the manifest group will
-heads = _(" (%+d heads)") % (newheads - oldheads)
+# be empty during the pull
+self.manifest.addgroup(chunkiter, revmap, tr)
-self.ui.status(_("added %d changesets"
-" with %d changes to %d files%s\n")
+# process the files
-% (changesets, revisions, files, heads))
+self.ui.status(_("adding file changes\n"))
+while 1:
-if changesets > 0:
+f = changegroup.getchunk(source)
-self.hook('pretxnchangegroup', throw=True,
+if not f:
-node=hex(self.changelog.node(cor+1)), source=srctype,
+break
-url=url)
+self.ui.debug(_("adding %s revisions\n") % f)
+fl = self.file(f)
-tr.close()
+o = fl.count()
+chunkiter = changegroup.chunkiter(source)
+if fl.addgroup(chunkiter, revmap, tr) is None:
+raise util.Abort(_("received file revlog group is empty"))
+revisions += fl.count() - o
+files += 1
+# make changelog see real files again
+cl.finalize(tr)
+newheads = len(self.changelog.heads())
+heads = ""
+if oldheads and newheads != oldheads:
+heads = _(" (%+d heads)") % (newheads - oldheads)
+self.ui.status(_("added %d changesets"
+" with %d changes to %d files%s\n")
+% (changesets, revisions, files, heads))
+if changesets > 0:
+self.hook('pretxnchangegroup', throw=True,
+node=hex(self.changelog.node(cor+1)), source=srctype,
+url=url)
+tr.close()
+finally:
+del tr
 if changesets > 0:
 self.hook("changegroup", node=hex(self.changelog.node(cor+1)),
 source=srctype, url=url)

changeset 4915	97b734fb9c6f
parent 4914	9a2a73ea6135
child 4916	5c5d23d93447