Patchwork [5,of,6] largefiles: wlock in status before lfdirstate.write()

login
register
mail settings
Submitter Mads Kiilerich
Date April 17, 2013, 2:11 a.m.
Message ID <5dbf61fe581870e2c5b3.1366164665@xps>
Download mbox | patch
Permalink /patch/1374/
State Accepted
Commit ac41bb76c737405217f186ece0b7ac03be7a091e
Headers show

Comments

Mads Kiilerich - April 17, 2013, 2:11 a.m.
# HG changeset patch
# User Mads Kiilerich <madski@unity3d.com>
# Date 1366162871 -7200
# Node ID 5dbf61fe581870e2c5b3a50c39dcc5f90cc161dc
# Parent  32a7b55e7d9f4052b8a4cfeccc3c7298e122fa85
largefiles: wlock in status before lfdirstate.write()
Matt Mackall - April 18, 2013, 5:43 a.m.
On Wed, 2013-04-17 at 04:11 +0200, Mads Kiilerich wrote:
> # HG changeset patch
> # User Mads Kiilerich <madski@unity3d.com>
> # Date 1366162871 -7200
> # Node ID 5dbf61fe581870e2c5b3a50c39dcc5f90cc161dc
> # Parent  32a7b55e7d9f4052b8a4cfeccc3c7298e122fa85
> largefiles: wlock in status before lfdirstate.write()

Queued for default, thanks.

Patch

diff --git a/hgext/largefiles/reposetup.py b/hgext/largefiles/reposetup.py
--- a/hgext/largefiles/reposetup.py
+++ b/hgext/largefiles/reposetup.py
@@ -126,127 +126,146 @@  def reposetup(ui, repo):
                 if match is None:
                     match = match_.always(self.root, self.getcwd())
 
-                # First check if there were files specified on the
-                # command line.  If there were, and none of them were
-                # largefiles, we should just bail here and let super
-                # handle it -- thus gaining a big performance boost.
-                lfdirstate = lfutil.openlfdirstate(ui, self)
-                if match.files() and not match.anypats():
-                    for f in lfdirstate:
-                        if match(f):
-                            break
-                    else:
-                        return super(lfilesrepo, self).status(node1, node2,
-                                match, listignored, listclean,
-                                listunknown, listsubrepos)
+                wlock = None
+                try:
+                    try:
+                        # updating the dirstate is optional
+                        # so we don't wait on the lock
+                        wlock = self.wlock(False)
+                    except error.LockError:
+                        pass
 
-                # Create a copy of match that matches standins instead
-                # of largefiles.
-                def tostandins(files):
-                    if not working:
-                        return files
-                    newfiles = []
-                    dirstate = self.dirstate
-                    for f in files:
-                        sf = lfutil.standin(f)
-                        if sf in dirstate:
-                            newfiles.append(sf)
-                        elif sf in dirstate.dirs():
-                            # Directory entries could be regular or
-                            # standin, check both
-                            newfiles.extend((f, sf))
+                    # First check if there were files specified on the
+                    # command line.  If there were, and none of them were
+                    # largefiles, we should just bail here and let super
+                    # handle it -- thus gaining a big performance boost.
+                    lfdirstate = lfutil.openlfdirstate(ui, self)
+                    if match.files() and not match.anypats():
+                        for f in lfdirstate:
+                            if match(f):
+                                break
                         else:
-                            newfiles.append(f)
-                    return newfiles
+                            return super(lfilesrepo, self).status(node1, node2,
+                                    match, listignored, listclean,
+                                    listunknown, listsubrepos)
 
-                m = copy.copy(match)
-                m._files = tostandins(m._files)
+                    # Create a copy of match that matches standins instead
+                    # of largefiles.
+                    def tostandins(files):
+                        if not working:
+                            return files
+                        newfiles = []
+                        dirstate = self.dirstate
+                        for f in files:
+                            sf = lfutil.standin(f)
+                            if sf in dirstate:
+                                newfiles.append(sf)
+                            elif sf in dirstate.dirs():
+                                # Directory entries could be regular or
+                                # standin, check both
+                                newfiles.extend((f, sf))
+                            else:
+                                newfiles.append(f)
+                        return newfiles
 
-                result = super(lfilesrepo, self).status(node1, node2, m,
-                    ignored, clean, unknown, listsubrepos)
-                if working:
+                    m = copy.copy(match)
+                    m._files = tostandins(m._files)
 
-                    def sfindirstate(f):
-                        sf = lfutil.standin(f)
-                        dirstate = self.dirstate
-                        return sf in dirstate or sf in dirstate.dirs()
+                    result = super(lfilesrepo, self).status(node1, node2, m,
+                        ignored, clean, unknown, listsubrepos)
+                    if working:
 
-                    match._files = [f for f in match._files
-                                    if sfindirstate(f)]
-                    # Don't waste time getting the ignored and unknown
-                    # files from lfdirstate
-                    s = lfdirstate.status(match, [], False,
-                            listclean, False)
-                    (unsure, modified, added, removed, missing, _unknown,
-                            _ignored, clean) = s
-                    if parentworking:
-                        for lfile in unsure:
-                            standin = lfutil.standin(lfile)
-                            if standin not in ctx1:
-                                # from second parent
-                                modified.append(lfile)
-                            elif ctx1[standin].data().strip() \
-                                    != lfutil.hashfile(self.wjoin(lfile)):
-                                modified.append(lfile)
-                            else:
-                                clean.append(lfile)
-                                lfdirstate.normal(lfile)
-                    else:
-                        tocheck = unsure + modified + added + clean
-                        modified, added, clean = [], [], []
+                        def sfindirstate(f):
+                            sf = lfutil.standin(f)
+                            dirstate = self.dirstate
+                            return sf in dirstate or sf in dirstate.dirs()
 
-                        for lfile in tocheck:
-                            standin = lfutil.standin(lfile)
-                            if inctx(standin, ctx1):
-                                if ctx1[standin].data().strip() != \
-                                        lfutil.hashfile(self.wjoin(lfile)):
+                        match._files = [f for f in match._files
+                                        if sfindirstate(f)]
+                        # Don't waste time getting the ignored and unknown
+                        # files from lfdirstate
+                        s = lfdirstate.status(match, [], False,
+                                listclean, False)
+                        (unsure, modified, added, removed, missing, _unknown,
+                                _ignored, clean) = s
+                        if parentworking:
+                            for lfile in unsure:
+                                standin = lfutil.standin(lfile)
+                                if standin not in ctx1:
+                                    # from second parent
+                                    modified.append(lfile)
+                                elif ctx1[standin].data().strip() \
+                                        != lfutil.hashfile(self.wjoin(lfile)):
                                     modified.append(lfile)
                                 else:
                                     clean.append(lfile)
-                            else:
-                                added.append(lfile)
+                                    lfdirstate.normal(lfile)
+                        else:
+                            tocheck = unsure + modified + added + clean
+                            modified, added, clean = [], [], []
 
-                    # Standins no longer found in lfdirstate has been removed
-                    for standin in ctx1.manifest():
-                        if not lfutil.isstandin(standin):
-                            continue
-                        lfile = lfutil.splitstandin(standin)
-                        if not match(lfile):
-                            continue
-                        if lfile not in lfdirstate:
-                            removed.append(lfile)
+                            for lfile in tocheck:
+                                standin = lfutil.standin(lfile)
+                                if inctx(standin, ctx1):
+                                    if ctx1[standin].data().strip() != \
+                                            lfutil.hashfile(self.wjoin(lfile)):
+                                        modified.append(lfile)
+                                    else:
+                                        clean.append(lfile)
+                                else:
+                                    added.append(lfile)
 
-                    # Filter result lists
-                    result = list(result)
+                        # Standins no longer found in lfdirstate has been
+                        # removed
+                        for standin in ctx1.manifest():
+                            if not lfutil.isstandin(standin):
+                                continue
+                            lfile = lfutil.splitstandin(standin)
+                            if not match(lfile):
+                                continue
+                            if lfile not in lfdirstate:
+                                removed.append(lfile)
 
-                    # Largefiles are not really removed when they're
-                    # still in the normal dirstate. Likewise, normal
-                    # files are not really removed if they are still in
-                    # lfdirstate. This happens in merges where files
-                    # change type.
-                    removed = [f for f in removed if f not in self.dirstate]
-                    result[2] = [f for f in result[2] if f not in lfdirstate]
+                        # Filter result lists
+                        result = list(result)
 
-                    lfiles = set(lfdirstate._map)
-                    # Unknown files
-                    result[4] = set(result[4]).difference(lfiles)
-                    # Ignored files
-                    result[5] = set(result[5]).difference(lfiles)
-                    # combine normal files and largefiles
-                    normals = [[fn for fn in filelist
-                                if not lfutil.isstandin(fn)]
-                               for filelist in result]
-                    lfiles = (modified, added, removed, missing, [], [], clean)
-                    result = [sorted(list1 + list2)
-                              for (list1, list2) in zip(normals, lfiles)]
-                else:
-                    def toname(f):
-                        if lfutil.isstandin(f):
-                            return lfutil.splitstandin(f)
-                        return f
-                    result = [[toname(f) for f in items] for items in result]
+                        # Largefiles are not really removed when they're
+                        # still in the normal dirstate. Likewise, normal
+                        # files are not really removed if they are still in
+                        # lfdirstate. This happens in merges where files
+                        # change type.
+                        removed = [f for f in removed
+                                   if f not in self.dirstate]
+                        result[2] = [f for f in result[2]
+                                     if f not in lfdirstate]
 
-                lfdirstate.write()
+                        lfiles = set(lfdirstate._map)
+                        # Unknown files
+                        result[4] = set(result[4]).difference(lfiles)
+                        # Ignored files
+                        result[5] = set(result[5]).difference(lfiles)
+                        # combine normal files and largefiles
+                        normals = [[fn for fn in filelist
+                                    if not lfutil.isstandin(fn)]
+                                   for filelist in result]
+                        lfiles = (modified, added, removed, missing, [], [],
+                                  clean)
+                        result = [sorted(list1 + list2)
+                                  for (list1, list2) in zip(normals, lfiles)]
+                    else:
+                        def toname(f):
+                            if lfutil.isstandin(f):
+                                return lfutil.splitstandin(f)
+                            return f
+                        result = [[toname(f) for f in items]
+                                  for items in result]
+
+                    if wlock:
+                        lfdirstate.write()
+
+                finally:
+                    if wlock:
+                        wlock.release()
 
                 if not listunknown:
                     result[4] = []