comparison mercurial/context.py @ 23702:c48924787eaa

filectx.parents: enforce changeid of parent to be in own changectx ancestors Because of the way filenodes are computed, you can have multiple changesets "introducing" the same file revision. For example, in the changeset graph below, changeset 2 and 3 both change a file -to- and -from- the same content. o 3: content = new | | o 2: content = new |/ o 1: content = old In such cases, the file revision is create once, when 2 is added, and just reused for 3. So the file change in '3' (from "old" to "new)" has no linkrev pointing to it). We'll call this situation "linkrev-shadowing". As the linkrev is used for optimization purposes when walking a file history, the linkrev-shadowing results in an unexpected jump to another branch during such a walk.. This leads to multiple bugs with log, annotate and rename detection. One element to fix such bugs is to ensure that walking the file history sticks on the same topology as the changeset's history. For this purpose, we extend the logic in 'basefilectx.parents' so that it always defines the proper changeset to associate the parent file revision with. This "proper" changeset has to be an ancestor of the changeset associated with the child file revision. This logic is performed in the '_adjustlinkrev' function. This function is given the starting changeset and all the information regarding the parent file revision. If the linkrev for the file revision is an ancestor of the starting changeset, the linkrev is valid and will be used. If it is not, we detected a topological jump caused by linkrev shadowing, we are going to walk the ancestors of the starting changeset until we find one setting the file to the revision we are trying to create. The performance impact appears acceptable: - We are walking the changelog once for each filelog traversal (as there should be no overlap between searches), - changelog traversal itself is fairly cheap, compared to what is likely going to be perform on the result on the filelog traversal, - We only touch the manifest for ancestors touching the file, And such changesets are likely to be the one introducing the file. (except in pathological cases involving merge), - We use manifest diff instead of full manifest unpacking to check manifest content, so it does not involve applying multiple diffs in most case. - linkrev shadowing is not the common case. Tests for fixed issues in log, annotate and rename detection have been added. But this changeset does not solve all problems. It fixes -ancestry- computation, but if the linkrev-shadowed changesets is the starting one, we'll still get things wrong. We'll have to fix the bootstrapping of such operations in a later changeset. Also, the usage of `hg log FILE` without --follow still has issues with linkrev pointing to hidden changesets, because it relies on the `filelog` revset which implement its own traversal logic that is still to be fixed. Thanks goes to: - Matt Mackall: for nudging me in the right direction - Julien Cristau and R?mi Cardona: for keep telling me linkrev bug were an evolution show stopper for 3 years. - Durham Goode: for finding a new linkrev issue every few weeks - Mads Kiilerich: for that last rename bug who raise this topic over my anoyance limit.
author Pierre-Yves David <pierre-yves.david@fb.com>
date Tue, 23 Dec 2014 15:30:38 -0800
parents 76320e2ed0a8
children aaa76612b3c0
comparison
equal deleted inserted replaced
23701:76320e2ed0a8 23702:c48924787eaa
19 19
20 # Phony node value to stand-in for new files in some uses of 20 # Phony node value to stand-in for new files in some uses of
21 # manifests. Manifests support 21-byte hashes for nodes which are 21 # manifests. Manifests support 21-byte hashes for nodes which are
22 # dirty in the working copy. 22 # dirty in the working copy.
23 _newnode = '!' * 21 23 _newnode = '!' * 21
24
25 def _adjustlinkrev(repo, path, filelog, fnode, srcrev):
26 """return the first ancestor of <srcrev> introducting <fnode>
27
28 If the linkrev of the file revision does not point to an ancestor of
29 srcrev, we'll walk down the ancestors until we find one introducing this
30 file revision.
31
32 :repo: a localrepository object (used to access changelog and manifest)
33 :path: the file path
34 :fnode: the nodeid of the file revision
35 :filelog: the filelog of this path
36 :srcrev: the changeset revision we search ancestors from
37 """
38 cl = repo.unfiltered().changelog
39 ma = repo.manifest
40 # fetch the linkrev
41 fr = filelog.rev(fnode)
42 lkr = filelog.linkrev(fr)
43 # check if this linkrev is an ancestor of srcrev
44 anc = cl.ancestors([srcrev], lkr)
45 if lkr not in anc:
46 for a in anc:
47 ac = cl.read(a) # get changeset data (we avoid object creation).
48 if path in ac[3]: # checking the 'files' field.
49 # The file has been touched, check if the content is similar
50 # to the one we search for.
51 if fnode == ma.readdelta(ac[0]).get(path):
52 return a
53 # In theory, we should never get out of that loop without a result. But
54 # if manifest uses a buggy file revision (not children of the one it
55 # replaces) we could. Such a buggy situation will likely result is crash
56 # somewhere else at to some point.
57 return lkr
24 58
25 class basectx(object): 59 class basectx(object):
26 """A basectx object represents the common logic for its children: 60 """A basectx object represents the common logic for its children:
27 changectx: read-only context that is already present in the repo, 61 changectx: read-only context that is already present in the repo,
28 workingctx: a context that represents the working directory and can 62 workingctx: a context that represents the working directory and can
737 _path = self._path 771 _path = self._path
738 fl = self._filelog 772 fl = self._filelog
739 parents = self._filelog.parents(self._filenode) 773 parents = self._filelog.parents(self._filenode)
740 pl = [(_path, node, fl) for node in parents if node != nullid] 774 pl = [(_path, node, fl) for node in parents if node != nullid]
741 775
742 r = self._filelog.renamed(self._filenode) 776 r = fl.renamed(self._filenode)
743 if r: 777 if r:
744 # - In the simple rename case, both parent are nullid, pl is empty. 778 # - In the simple rename case, both parent are nullid, pl is empty.
745 # - In case of merge, only one of the parent is null id and should 779 # - In case of merge, only one of the parent is null id and should
746 # be replaced with the rename information. This parent is -always- 780 # be replaced with the rename information. This parent is -always-
747 # the first one. 781 # the first one.
749 # As null id have alway been filtered out in the previous list 783 # As null id have alway been filtered out in the previous list
750 # comprehension, inserting to 0 will always result in "replacing 784 # comprehension, inserting to 0 will always result in "replacing
751 # first nullid parent with rename information. 785 # first nullid parent with rename information.
752 pl.insert(0, (r[0], r[1], self._repo.file(r[0]))) 786 pl.insert(0, (r[0], r[1], self._repo.file(r[0])))
753 787
754 return [filectx(self._repo, p, fileid=n, filelog=l) for p, n, l in pl] 788 ret = []
789 for path, fnode, l in pl:
790 if '_changeid' in vars(self) or '_changectx' in vars(self):
791 # If self is associated with a changeset (probably explicitly
792 # fed), ensure the created filectx is associated with a
793 # changeset that is an ancestor of self.changectx.
794 rev = _adjustlinkrev(self._repo, path, l, fnode, self.rev())
795 fctx = filectx(self._repo, path, fileid=fnode, filelog=l,
796 changeid=rev)
797 else:
798 fctx = filectx(self._repo, path, fileid=fnode, filelog=l)
799 ret.append(fctx)
800 return ret
755 801
756 def p1(self): 802 def p1(self):
757 return self.parents()[0] 803 return self.parents()[0]
758 804
759 def p2(self): 805 def p2(self):