Use try/finally pattern to cleanup locks and transactions

hgext/fetch.py

@@ -19,7 +19,7 b" def fetch(ui, repo, source='default', **"
     merged, and the result of the merge is committed.  Otherwise, the
     working directory is updated.'''
 
-    def postincoming(other, modheads):
+    def postincoming(other, modheads, lock, wlock):
         if modheads == 0:
             return 0
         if modheads == 1:
@@ -50,7 +50,7 b" def fetch(ui, repo, source='default', **"
             ui.status(_('new changeset %d:%s merges remote changes '
                         'with local\n') % (repo.changelog.rev(n),
                                            short(n)))
-    def pull():
+    def pull(lock, wlock):
         cmdutil.setremoteconfig(ui, opts)
 
         other = hg.repository(ui, ui.expandpath(source))
@@ -61,7 +61,7 b" def fetch(ui, repo, source='default', **"
         elif opts['rev']:
             revs = [other.lookup(rev) for rev in opts['rev']]
         modheads = repo.pull(other, heads=revs, lock=lock)
-        return postincoming(other, modheads)
+        return postincoming(other, modheads, lock, wlock)
 
     parent, p2 = repo.dirstate.parents()
     if parent != repo.changelog.tip():
@@ -69,19 +69,19 b" def fetch(ui, repo, source='default', **"
                            '(use "hg update" to check out tip)'))
     if p2 != nullid:
         raise util.Abort(_('outstanding uncommitted merge'))
+    wlock = lock = None
+    try:
     wlock = repo.wlock()
     lock = repo.lock()
-    try:
         mod, add, rem = repo.status(wlock=wlock)[:3]
         if mod or add or rem:
             raise util.Abort(_('outstanding uncommitted changes'))
         if len(repo.heads()) > 1:
             raise util.Abort(_('multiple heads in this repository '
                                '(use "hg heads" and "hg merge" to merge)'))
-        return pull()
+        return pull(lock, wlock)
     finally:
-        lock.release()
-        wlock.release()
+        del lock, wlock
 
 cmdtable = {
     'fetch':

hgext/mq.py

@@ -439,6 +439,8 b' class queue:'
     def apply(self, repo, series, list=False, update_status=True,
               strict=False, patchdir=None, merge=None, wlock=None,
               all_files={}):
+        lock = tr = None
+        try:
         if not wlock:
             wlock = repo.wlock()
         lock = repo.lock()
@@ -457,6 +459,8 b' class queue:'
                 repo.invalidate()
                 repo.dirstate.invalidate()
             raise
+        finally:
+            del lock, wlock, tr
 
     def _apply(self, tr, repo, series, list=False, update_status=True,
                strict=False, patchdir=None, merge=None, wlock=None,
@@ -616,6 +620,7 b' class queue:'
         commitfiles = m + a + r
         self.check_toppatch(repo)
         wlock = repo.wlock()
+        try:
         insert = self.full_series_end()
         if msg:
             n = repo.commit(commitfiles, msg, force=True, wlock=wlock)
@@ -640,8 +645,12 b' class queue:'
         if commitfiles:
             self.refresh(repo, short=True)
         self.removeundo(repo)
+        finally:
+            del wlock
 
     def strip(self, repo, rev, update=True, backup="all", wlock=None):
+        lock = None
+        try:
         if not wlock:
             wlock = repo.wlock()
         lock = repo.lock()
@@ -654,6 +663,8 b' class queue:'
 
         self.removeundo(repo)
         repair.strip(self.ui, repo, rev, backup)
+        finally:
+            del lock, wlock
 
     def isapplied(self, patch):
         """returns (index, rev, patch)"""
@@ -740,27 +751,30 b' class queue:'
              mergeq=None, wlock=None):
         if not wlock:
             wlock = repo.wlock()
+        try:
         patch = self.lookup(patch)
-        # Suppose our series file is: A B C and the current 'top' patch is B.
-        # qpush C should be performed (moving forward)
-        # qpush B is a NOP (no change)
-        # qpush A is an error (can't go backwards with qpush)
+            # Suppose our series file is: A B C and the current 'top'
+            # patch is B. qpush C should be performed (moving forward)
+            # qpush B is a NOP (no change) qpush A is an error (can't
+            # go backwards with qpush)
         if patch:
             info = self.isapplied(patch)
             if info:
                 if info[0] < len(self.applied) - 1:
-                    raise util.Abort(_("cannot push to a previous patch: %s") %
-                                     patch)
+                        raise util.Abort(
+                            _("cannot push to a previous patch: %s") % patch)
                 if info[0] < len(self.series) - 1:
-                    self.ui.warn(_('qpush: %s is already at the top\n') % patch)
+                        self.ui.warn(
+                            _('qpush: %s is already at the top\n') % patch)
                 else:
                     self.ui.warn(_('all patches are currently applied\n'))
                 return
 
         # Following the above example, starting at 'top' of B:
-        #  qpush should be performed (pushes C), but a subsequent qpush without
-        #  an argument is an error (nothing to apply). This allows a loop
-        #  of "...while hg qpush..." to work as it detects an error when done
+            # qpush should be performed (pushes C), but a subsequent
+            # qpush without an argument is an error (nothing to
+            # apply). This allows a loop of "...while hg qpush..." to
+            # work as it detects an error when done
         if self.series_end() == len(self.series):
             self.ui.warn(_('patch series already fully applied\n'))
             return 1
@@ -798,11 +812,13 b' class queue:'
             raise
         top = self.applied[-1].name
         if ret[0]:
-            self.ui.write("Errors during apply, please fix and refresh %s\n" %
-                          top)
+                self.ui.write(
+                    "Errors during apply, please fix and refresh %s\n" % top)
         else:
             self.ui.write("Now at: %s\n" % top)
         return ret[0]
+        finally:
+            del wlock
 
     def pop(self, repo, patch=None, force=False, update=True, all=False,
             wlock=None):
@@ -812,6 +828,7 b' class queue:'
 
         if not wlock:
             wlock = repo.wlock()
+        try:
         if patch:
             # index, rev, patch
             info = self.isapplied(patch)
@@ -888,6 +905,8 b' class queue:'
             self.ui.write("Now at: %s\n" % self.applied[-1].name)
         else:
             self.ui.write("Patch queue now empty\n")
+        finally:
+            del wlock
 
     def diff(self, repo, pats, opts):
         top = self.check_toppatch(repo)
@@ -904,6 +923,7 b' class queue:'
             self.ui.write("No patches applied\n")
             return 1
         wlock = repo.wlock()
+        try:
         self.check_toppatch(repo)
         (top, patchfn) = (self.applied[-1].rev, self.applied[-1].name)
         top = revlog.bin(top)
@@ -969,9 +989,10 b' class queue:'
                 match = util.always
             m, a, r, d, u = repo.status(files=filelist, match=match)[:5]
 
-            # we might end up with files that were added between tip and
-            # the dirstate parent, but then changed in the local dirstate.
-            # in this case, we want them to only show up in the added section
+                # we might end up with files that were added between
+                # tip and the dirstate parent, but then changed in the
+                # local dirstate. in this case, we want them to only
+                # show up in the added section
             for x in m:
                 if x not in aa:
                     mm.append(x)
@@ -1031,8 +1052,8 b' class queue:'
                     repo.dirstate.copy(src, dst)
             for f in r:
                 repo.dirstate.remove(f)
-            # if the patch excludes a modified file, mark that file with mtime=0
-            # so status can see it.
+                # if the patch excludes a modified file, mark that
+                # file with mtime=0 so status can see it.
             mm = []
             for i in xrange(len(m)-1, -1, -1):
                 if not matchfn(m[i]):
@@ -1053,7 +1074,8 b' class queue:'
             else:
                 message = msg
 
-            self.strip(repo, top, update=False, backup='strip', wlock=wlock)
+                self.strip(repo, top, update=False,
+                           backup='strip', wlock=wlock)
             n = repo.commit(filelist, message, changes[1], match=matchfn,
                             force=1, wlock=wlock)
             self.applied[-1] = statusentry(revlog.hex(n), patchfn)
@@ -1077,6 +1099,8 b' class queue:'
                 repo.dirstate.forget(a)
             self.pop(repo, force=True, wlock=wlock)
             self.push(repo, force=True, wlock=wlock)
+        finally:
+            del wlock
 
     def init(self, repo, create=False):
         if not create and os.path.isdir(self.path):
@@ -1872,10 +1896,13 b' def rename(ui, repo, patch, name=None, *'
     r = q.qrepo()
     if r:
         wlock = r.wlock()
+        try:
         if r.dirstate[name] == 'r':
             r.undelete([name], wlock)
         r.copy(patch, name, wlock)
         r.remove([patch], False, wlock)
+        finally:
+            del wlock
 
     q.save_dirty()
 

hgext/transplant.py

@@ -96,9 +96,10 b' class transplanter:'
         diffopts = patch.diffopts(self.ui, opts)
         diffopts.git = True
 
+        lock = wlock = None
+        try:
         wlock = repo.wlock()
         lock = repo.lock()
-        try:
             for rev in revs:
                 node = revmap[rev]
                 revstr = '%s:%s' % (rev, revlog.short(node))
@@ -166,6 +167,7 b' class transplanter:'
         finally:
             self.saveseries(revmap, merges)
             self.transplants.write()
+            del lock, wlock
 
     def filter(self, filter, changelog, patchfile):
         '''arbitrarily rewrite changeset before applying it'''
@@ -272,13 +274,16 b' class transplanter:'
 
         extra = {'transplant_source': node}
         wlock = repo.wlock()
+        try:
         p1, p2 = repo.dirstate.parents()
         if p1 != parents[0]:
-            raise util.Abort(_('working dir not at transplant parent %s') %
+                raise util.Abort(
+                    _('working dir not at transplant parent %s') %
                              revlog.hex(parents[0]))
         if merge:
             repo.dirstate.setparents(p1, parents[1])
-        n = repo.commit(None, message, user, date, wlock=wlock, extra=extra)
+            n = repo.commit(None, message, user, date, wlock=wlock,
+                            extra=extra)
         if not n:
             raise util.Abort(_('commit failed'))
         if not merge:
@@ -286,6 +291,8 b' class transplanter:'
         self.unlog()
 
         return n, node
+        finally:
+            del wlock
 
     def readseries(self):
         nodes = []

mercurial/commands.py

@@ -676,7 +676,10 b' def copy(ui, repo, *pats, **opts):'
     before that, see hg revert.
     """
     wlock = repo.wlock(False)
+    try:
     errs, copied = docopy(ui, repo, pats, opts, wlock)
+    finally:
+        del wlock
     return errs
 
 def debugancestor(ui, index, rev1, rev2):
@@ -713,7 +716,10 b' def debugrebuildstate(ui, repo, rev=""):'
     ctx = repo.changectx(rev)
     files = ctx.manifest()
     wlock = repo.wlock()
+    try:
     repo.dirstate.rebuild(rev, files)
+    finally:
+        del wlock
 
 def debugcheckstate(ui, repo):
     """validate the correctness of the current dirstate"""
@@ -782,7 +788,7 b' def debugsetparents(ui, repo, rev1, rev2'
     try:
         repo.dirstate.setparents(repo.lookup(rev1), repo.lookup(rev2))
     finally:
-        wlock.release()
+        del wlock
 
 def debugstate(ui, repo):
     """show the contents of the current dirstate"""
@@ -1581,19 +1587,21 b' def import_(ui, repo, patch1, *patches, '
 
     d = opts["base"]
     strip = opts["strip"]
-
+    wlock = lock = None
+    try:
     wlock = repo.wlock()
     lock = repo.lock()
-
     for p in patches:
         pf = os.path.join(d, p)
 
         if pf == '-':
             ui.status(_("applying patch from stdin\n"))
-            tmpname, message, user, date, branch, nodeid, p1, p2 = patch.extract(ui, sys.stdin)
+                data = patch.extract(ui, sys.stdin)
         else:
             ui.status(_("applying %s\n") % p)
-            tmpname, message, user, date, branch, nodeid, p1, p2 = patch.extract(ui, file(pf, 'rb'))
+                data = patch.extract(ui, file(pf, 'rb'))
+
+            tmpname, message, user, date, branch, nodeid, p1, p2 = data
 
         if tmpname is None:
             raise util.Abort(_('no diffs found'))
@@ -1638,13 +1646,17 b' def import_(ui, repo, patch1, *patches, '
                                    files=files)
             finally:
                 files = patch.updatedir(ui, repo, files, wlock=wlock)
-            n = repo.commit(files, message, user, date, wlock=wlock, lock=lock)
+                n = repo.commit(files, message, user, date, wlock=wlock,
+                                lock=lock)
             if opts.get('exact'):
                 if hex(n) != nodeid:
                     repo.rollback(wlock=wlock, lock=lock)
-                    raise util.Abort(_('patch is damaged or loses information'))
+                        raise util.Abort(_('patch is damaged' +
+                                           ' or loses information'))
         finally:
             os.unlink(tmpname)
+    finally:
+        del wlock, lock
 
 def incoming(ui, repo, source="default", **opts):
     """show new changesets found in source
@@ -2248,6 +2260,7 b' def rename(ui, repo, *pats, **opts):'
     before that, see hg revert.
     """
     wlock = repo.wlock(False)
+    try:
     errs, copied = docopy(ui, repo, pats, opts, wlock)
     names = []
     for abs, rel, exact in copied:
@@ -2257,6 +2270,8 b' def rename(ui, repo, *pats, **opts):'
     if not opts.get('dry_run'):
         repo.remove(names, True, wlock=wlock)
     return errs
+    finally:
+        del wlock
 
 def revert(ui, repo, *pats, **opts):
     """revert files or dirs to their states as of some revision
@@ -2310,8 +2325,6 b' def revert(ui, repo, *pats, **opts):'
     else:
         pmf = None
 
-    wlock = repo.wlock()
-
     # need all matching names in dirstate and manifest of target rev,
     # so have to walk both. do not print errors if files exist in one
     # but not other.
@@ -2319,8 +2332,9 b' def revert(ui, repo, *pats, **opts):'
     names = {}
     target_only = {}
 
+    wlock = repo.wlock()
+    try:
     # walk dirstate.
-
     for src, abs, rel, exact in cmdutil.walk(repo, pats, opts,
                                              badmatch=mf.has_key):
         names[abs] = (rel, exact)
@@ -2426,6 +2440,8 b' def revert(ui, repo, *pats, **opts):'
         for f in remove[0]:
             repo.dirstate.remove(f)
         return r
+    finally:
+        del wlock
 
 def rollback(ui, repo):
     """roll back the last transaction in this repository

mercurial/hg.py

@@ -130,7 +130,8 b' def clone(ui, source, dest=None, pull=Fa'
             if self.dir_:
                 self.rmtree(self.dir_, True)
 
-    dir_cleanup = None
+    src_lock = dest_lock = dir_cleanup = None
+    try:
     if islocal(dest):
         dir_cleanup = DirCleanup(dest)
 
@@ -140,7 +141,6 b' def clone(ui, source, dest=None, pull=Fa'
         abspath = os.path.abspath(origsource)
         copy = not pull and not rev
 
-    src_lock, dest_lock = None, None
     if copy:
         try:
             # we use a lock here because if we race with commit, we
@@ -205,18 +205,12 b' def clone(ui, source, dest=None, pull=Fa'
         else:
             raise util.Abort(_("clone from remote to remote not supported"))
 
-    if src_lock:
-        src_lock.release()
-
     if dest_repo.local():
         fp = dest_repo.opener("hgrc", "w", text=True)
         fp.write("[paths]\n")
         fp.write("default = %s\n" % abspath)
         fp.close()
 
-        if dest_lock:
-            dest_lock.release()
-
         if update:
             try:
                 checkout = dest_repo.lookup("default")
@@ -227,6 +221,8 b' def clone(ui, source, dest=None, pull=Fa'
         dir_cleanup.close()
 
     return src_repo, dest_repo
+    finally:
+        del src_lock, dest_lock, dir_cleanup
 
 def _showstats(repo, stats):
     stats = ((stats[0], _("updated")),

mercurial/hgweb/hgweb_mod.py

@@ -1168,7 +1168,7 b' class hgweb(object):'
                     req.write('%d\n' % ret)
                     req.write(val)
                 finally:
-                    lock.release()
+                    del lock
             except (OSError, IOError), inst:
                 req.write('0\n')
                 filename = getattr(inst, 'filename', '')

mercurial/localrepo.py

@@ -516,6 +516,7 b' class localrepository(repo.repository):'
 
     def recover(self):
         l = 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"))
@@ -524,8 +525,11 b' class localrepository(repo.repository):'
         else:
             self.ui.warn(_("no interrupted transaction available\n"))
             return False
+        finally:
+            del l
 
     def rollback(self, wlock=None, lock=None):
+        try:
         if not wlock:
             wlock = self.wlock()
         if not lock:
@@ -538,6 +542,8 b' class localrepository(repo.repository):'
             self.dirstate.invalidate()
         else:
             self.ui.warn(_("no rollback information available\n"))
+        finally:
+            del wlock, lock
 
     def invalidate(self):
         for a in "changelog manifest".split():
@@ -639,7 +645,8 b' class localrepository(repo.repository):'
     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
+        try:
         commit = []
         remove = []
         changed = []
@@ -717,8 +724,9 b' class localrepository(repo.repository):'
                 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.
+                        # 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:
@@ -742,7 +750,8 b' class localrepository(repo.repository):'
                 removed.append(f)
             elif f in m2:
                 removed.append(f)
-        mn = self.manifest.add(m1, tr, linkrev, c1[0], c2[0], (new, removed))
+            mn = self.manifest.add(m1, tr, linkrev, c1[0], c2[0],
+                                   (new, removed))
 
         # add changeset
         new = new.keys()
@@ -797,6 +806,8 b' class localrepository(repo.repository):'
 
         self.hook("commit", node=hex(n), parent1=xp1, parent2=xp2)
         return n
+        finally:
+            del lock, wlock, tr
 
     def walk(self, node=None, files=[], match=util.always, badmatch=None):
         '''
@@ -895,18 +906,18 b' class localrepository(repo.repository):'
 
                     # update dirstate for files that are actually clean
                     if fixup:
-                        cleanup = False
-                        if not wlock:
+                        fixlock = wlock
                             try:
-                                wlock = self.wlock(False)
-                                cleanup = True
+                            if not fixlock:
+                                try:
+                                    fixlock = self.wlock(False)
                             except lock.LockException:
                                 pass
-                        if wlock:
+                            if fixlock:
                             for f in fixup:
                                 self.dirstate.normal(f)
-                        if cleanup:
-                                wlock.release()
+                        finally:
+                            del fixlock
             else:
                 # we are comparing working dir against non-parent
                 # generate a pseudo-manifest for the working dir
@@ -954,6 +965,7 b' class localrepository(repo.repository):'
         return (modified, added, removed, deleted, unknown, ignored, clean)
 
     def add(self, list, wlock=None):
+        try:
         if not wlock:
             wlock = self.wlock()
         for f in list:
@@ -975,8 +987,11 b' class localrepository(repo.repository):'
                 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:
@@ -984,8 +999,11 b' class localrepository(repo.repository):'
                 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:
@@ -1004,8 +1022,11 b' class localrepository(repo.repository):'
                 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)
@@ -1018,8 +1039,11 b' class localrepository(repo.repository):'
                 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)
@@ -1032,6 +1056,8 b' class localrepository(repo.repository):'
             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)
@@ -1309,12 +1335,9 b' class localrepository(repo.repository):'
             return subset
 
     def pull(self, remote, heads=None, force=False, lock=None):
-        mylock = False
+        try:
         if not lock:
             lock = self.lock()
-            mylock = True
-
-        try:
             fetch = self.findincoming(remote, force=force)
             if fetch == [nullid]:
                 self.ui.status(_("requesting all changes\n"))
@@ -1331,8 +1354,7 b' class localrepository(repo.repository):'
                 cg = remote.changegroupsubset(fetch, heads, 'pull')
             return self.addchangegroup(cg, 'pull', remote.url())
         finally:
-            if mylock:
-                lock.release()
+            del lock
 
     def push(self, remote, force=False, revs=None):
         # there are two ways to push to remote repo:
@@ -1405,12 +1427,14 b' class localrepository(repo.repository):'
 
     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
@@ -1794,14 +1818,14 b' class localrepository(repo.repository):'
 
         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())
 
+        tr = self.transaction()
+        try:
         # pull off the changeset group
         self.ui.status(_("adding changesets\n"))
         cor = cl.count() - 1
@@ -1853,6 +1877,8 b' class localrepository(repo.repository):'
                       url=url)
 
         tr.close()
+        finally:
+            del tr
 
         if changesets > 0:
             self.hook("changegroup", node=hex(self.changelog.node(cor+1)),

mercurial/merge.py

@@ -506,6 +506,7 b' def update(repo, node, branchmerge, forc'
     wlock = working dir lock, if already held
     """
 
+    try:
     if not wlock:
         wlock = repo.wlock()
 
@@ -567,4 +568,5 b' def update(repo, node, branchmerge, forc'
         repo.hook('update', parent1=xp1, parent2=xp2, error=stats[3])
 
     return stats
-
+    finally:
+        del wlock

mercurial/streamclone.py

@@ -66,6 +66,8 b' def stream_out(repo, fileobj, untrusted='
 
     # get consistent snapshot of repo. lock during scan so lock not
     # needed while we stream, and commits can happen.
+    lock = None
+    try:
     try:
         repolock = repo.lock()
     except (lock.LockHeld, lock.LockUnavailable), inst:
@@ -81,7 +83,8 b' def stream_out(repo, fileobj, untrusted='
         name = repo.decodefn(util.pconvert(name))
         entries.append((name, size))
         total_bytes += size
-    repolock.release()
+    finally:
+        del repolock
 
     repo.ui.debug('%d files, %d bytes to transfer\n' %
                   (len(entries), total_bytes))

mercurial/verify.py

@@ -10,6 +10,13 b' from i18n import _'
 import revlog, mdiff
 
 def verify(repo):
+    lock = repo.lock()
+    try:
+        return _verify(repo)
+    finally:
+        del lock
+
+def _verify(repo):
     filelinkrevs = {}
     filenodes = {}
     changesets = revisions = files = 0
@@ -17,8 +24,6 b' def verify(repo):'
     warnings = [0]
     neededmanifests = {}
 
-    lock = repo.lock()
-
     def err(msg):
         repo.ui.warn(msg + "\n")
         errors[0] += 1