mercurial-scm/hg: comparison mercurial/localrepo.py

equal deleted inserted replaced

-:a26d33749bd8
+:496ae1ea4698
 import changelog, dirstate, filelog, manifest, context, weakref
 import lock, transaction, stat, errno, ui, store, encoding
 import os, time, util, extensions, hook, inspect, error
 import match as match_
 import merge as merge_
+from lock import release
 class localrepository(repo.repository):
 capabilities = util.set(('lookup', 'changegroupsubset'))
 supported = ('revlogv1', 'store', 'fncache')
 self.store.createmode)
 self._transref = weakref.ref(tr)
 return tr
 def recover(self):
-l = self.lock()
+lock = self.lock()
 try:
 if os.path.exists(self.sjoin("journal")):
 self.ui.status(_("rolling back interrupted transaction\n"))
 transaction.rollback(self.sopener, self.sjoin("journal"))
 self.invalidate()
 return True
 else:
 self.ui.warn(_("no interrupted transaction available\n"))
 return False
 finally:
-del l
+lock.release()
 def rollback(self):
 wlock = lock = None
 try:
 wlock = self.wlock()
 self.invalidate()
 self.dirstate.invalidate()
 else:
 self.ui.warn(_("no rollback information available\n"))
 finally:
-del lock, wlock
+release(lock, wlock)
 def invalidate(self):
 for a in "changelog manifest".split():
 if a in self.__dict__:
 delattr(self, a)
 use_dirstate, update_dirstate)
 ms.reset()
 return r
 finally:
-del lock, wlock
+release(lock, wlock)
 def commitctx(self, ctx):
 """Add a new revision to current repository.
 Revision information is passed in the context.memctx argument.
 lock = self.lock()
 return self._commitctx(ctx, force=True, force_editor=False,
 empty_ok=True, use_dirstate=False,
 update_dirstate=False)
 finally:
-del lock, wlock
+release(lock, wlock)
 def _commitctx(self, wctx, force=False, force_editor=False, empty_ok=False,
 use_dirstate=True, update_dirstate=True):
 tr = None
 valid = 0 # don't save the dirstate if this isn't set
 for f in fixup:
 self.dirstate.normal(f)
 except error.LockError:
 pass
 finally:
-del wlock
+release(wlock)
 if not parentworking:
 mf1 = mfmatches(ctx1)
 if working:
 # we are comparing working dir against non-parent
 self.dirstate.normallookup(f)
 else:
 self.dirstate.add(f)
 return rejected
 finally:
-del wlock
+wlock.release()
 def forget(self, list):
 wlock = self.wlock()
 try:
 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
+wlock.release()
 def remove(self, list, unlink=False):
 wlock = None
 try:
 if unlink:
 elif f not in self.dirstate:
 self.ui.warn(_("%s not tracked!\n") % f)
 else:
 self.dirstate.remove(f)
 finally:
-del wlock
+release(wlock)
 def undelete(self, list):
-wlock = None
+manifests = [self.manifest.read(self.changelog.read(p)[0])
-try:
+for p in self.dirstate.parents() if p != nullid]
-manifests = [self.manifest.read(self.changelog.read(p)[0])
+wlock = self.wlock()
-for p in self.dirstate.parents() if p != nullid]
+try:
-wlock = self.wlock()
 for f in list:
 if self.dirstate[f] != 'r':
 self.ui.warn(_("%s not removed!\n") % f)
 else:
 m = f in manifests[0] and manifests[0] or manifests[1]
 t = self.file(f).read(m[f])
 self.wwrite(f, t, m.flags(f))
 self.dirstate.normal(f)
 finally:
-del wlock
+wlock.release()
 def copy(self, source, dest):
-wlock = None
+p = self.wjoin(dest)
-try:
+if not (os.path.exists(p) or os.path.islink(p)):
-p = self.wjoin(dest)
+self.ui.warn(_("%s does not exist!\n") % dest)
-if not (os.path.exists(p) or os.path.islink(p)):
+elif not (os.path.isfile(p) or os.path.islink(p)):
-self.ui.warn(_("%s does not exist!\n") % dest)
+self.ui.warn(_("copy failed: %s is not a file or a "
-elif not (os.path.isfile(p) or os.path.islink(p)):
+"symbolic link\n") % dest)
-self.ui.warn(_("copy failed: %s is not a file or a "
+else:
-"symbolic link\n") % dest)
+wlock = self.wlock()
-else:
+try:
-wlock = self.wlock()
 if self.dirstate[dest] in '?r':
 self.dirstate.add(dest)
 self.dirstate.copy(source, dest)
 finally:
-del wlock
+wlock.release()
 def heads(self, start=None, closed=True):
 heads = self.changelog.heads(start)
 def display(head):
 if closed:
 if not remote.capable('changegroupsubset'):
 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:
-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
 if ret[0] is not None:
 cg, remote_heads = ret
 return remote.addchangegroup(cg, 'push', self.url())
 return ret[1]
 finally:
-del lock
+lock.release()
 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

changeset 8109	496ae1ea4698
parent 8108	a26d33749bd8
child 8111	dbf20df40eb1