Mercurial > public > mercurial-scm > hg-stable
annotate mercurial/phases.py @ 51407:2f39c7aeb549
phases: large rewrite on retract boundary
The new code is still pure Python, so we still have room to going significantly
faster. However its complexity of the complex part is `O(|[min_new_draft, tip]|)` instead of
`O(|[min_draft, tip]|` which should help tremendously one repository with old
draft (like mercurial-devel or mozilla-try).
This is especially useful as the most common "retract boundary" operation
happens when we commit/rewrite new drafts or when we push new draft to a
non-publishing server. In this case, the smallest new_revs is very close to the
tip and there is very few work to do.
A few smaller optimisation could be done for these cases and will be introduced in
later changesets.
We still have iterate over large sets of roots, but this is already a great
improvement for a very small amount of work. We gather information on the
affected changeset as we go as we can put it to use in the next changesets.
This extra data collection might slowdown the `register_new` case a bit, however
for register_new, it should not really matters. The set of new nodes is either
small, so the impact is negligible, or the set of new nodes is large, and the
amount of work to do to had them will dominate the overhead the collecting
information in `changed_revs`.
As this new code compute the changes on the fly, it unlock other interesting
improvement to be done in later changeset.
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Wed, 21 Feb 2024 10:41:09 +0100 |
parents | 330d74750668 |
children | eababb7b4a82 |
rev | line source |
---|---|
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
1 """ Mercurial phases support code |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
2 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
3 --- |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
4 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
5 Copyright 2011 Pierre-Yves David <pierre-yves.david@ens-lyon.org> |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
6 Logilab SA <contact@logilab.fr> |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
7 Augie Fackler <durin42@gmail.com> |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
8 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
9 This software may be used and distributed according to the terms |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
10 of the GNU General Public License version 2 or any later version. |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
11 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
12 --- |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
13 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
14 This module implements most phase logic in mercurial. |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
15 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
16 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
17 Basic Concept |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
18 ============= |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
19 |
16724
00535da82faf
phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents:
16659
diff
changeset
|
20 A 'changeset phase' is an indicator that tells us how a changeset is |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
21 manipulated and communicated. The details of each phase is described |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
22 below, here we describe the properties they have in common. |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
23 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
24 Like bookmarks, phases are not stored in history and thus are not |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
25 permanent and leave no audit trail. |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
26 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
27 First, no changeset can be in two phases at once. Phases are ordered, |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
28 so they can be considered from lowest to highest. The default, lowest |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
29 phase is 'public' - this is the normal phase of existing changesets. A |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
30 child changeset can not be in a lower phase than its parents. |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
31 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
32 These phases share a hierarchy of traits: |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
33 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
34 immutable shared |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
35 public: X X |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
36 draft: X |
15705
e34f4d1f0dbb
phases: update doc to mention secret phase
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15697
diff
changeset
|
37 secret: |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
38 |
16724
00535da82faf
phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents:
16659
diff
changeset
|
39 Local commits are draft by default. |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
40 |
16724
00535da82faf
phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents:
16659
diff
changeset
|
41 Phase Movement and Exchange |
00535da82faf
phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents:
16659
diff
changeset
|
42 =========================== |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
43 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
44 Phase data is exchanged by pushkey on pull and push. Some servers have |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
45 a publish option set, we call such a server a "publishing server". |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
46 Pushing a draft changeset to a publishing server changes the phase to |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
47 public. |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
48 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
49 A small list of fact/rules define the exchange of phase: |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
50 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
51 * old client never changes server states |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
52 * pull never changes server states |
16724
00535da82faf
phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents:
16659
diff
changeset
|
53 * publish and old server changesets are seen as public by client |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
54 * any secret changeset seen in another repository is lowered to at |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
55 least draft |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
56 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
57 Here is the final table summing up the 49 possible use cases of phase |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
58 exchange: |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
59 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
60 server |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
61 old publish non-publish |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
62 N X N D P N D P |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
63 old client |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
64 pull |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
65 N - X/X - X/D X/P - X/D X/P |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
66 X - X/X - X/D X/P - X/D X/P |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
67 push |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
68 X X/X X/X X/P X/P X/P X/D X/D X/P |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
69 new client |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
70 pull |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
71 N - P/X - P/D P/P - D/D P/P |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
72 D - P/X - P/D P/P - D/D P/P |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
73 P - P/X - P/D P/P - P/D P/P |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
74 push |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
75 D P/X P/X P/P P/P P/P D/D D/D P/P |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
76 P P/X P/X P/P P/P P/P P/P P/P P/P |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
77 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
78 Legend: |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
79 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
80 A/B = final state on client / state on server |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
81 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
82 * N = new/not present, |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
83 * P = public, |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
84 * D = draft, |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
85 * X = not tracked (i.e., the old client or server has no internal |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
86 way of recording the phase.) |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
87 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
88 passive = only pushes |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
89 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
90 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
91 A cell here can be read like this: |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
92 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
93 "When a new client pushes a draft changeset (D) to a publishing |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
94 server where it's not present (N), it's marked public on both |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
95 sides (P/P)." |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
96 |
16724
00535da82faf
phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents:
16659
diff
changeset
|
97 Note: old client behave as a publishing server with draft only content |
15659
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
98 - other people see it as public |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
99 - content is pushed as draft |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
100 |
7fba5a245acc
phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15649
diff
changeset
|
101 """ |
15417
5261140d9322
phases: Minimal first add.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
diff
changeset
|
102 |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
103 |
34326
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
104 import struct |
51302
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
105 import typing |
51402
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
106 import weakref |
51302
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
107 |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
108 from typing import ( |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
109 Any, |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
110 Callable, |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
111 Dict, |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
112 Iterable, |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
113 List, |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
114 Optional, |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
115 Set, |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
116 Tuple, |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
117 ) |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
118 |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
119 from .i18n import _ |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
120 from .node import ( |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
121 bin, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
122 hex, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
123 nullrev, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
124 short, |
44007
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43763
diff
changeset
|
125 wdirrev, |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
126 ) |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
127 from . import ( |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
128 error, |
35318
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
129 pycompat, |
45392
77b8588dd84e
requirements: introduce new requirements related module
Pulkit Goyal <7895pulkit@gmail.com>
parents:
45376
diff
changeset
|
130 requirements, |
31036
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30639
diff
changeset
|
131 smartset, |
31073
6afd8a87a657
phases: check HG_PENDING strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31036
diff
changeset
|
132 txnutil, |
32000
511a62669f1b
phases: emit phases to pushkey protocol in deterministic order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31351
diff
changeset
|
133 util, |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
134 ) |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
135 |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
136 Phaseroots = Dict[int, Set[int]] |
51302
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
137 |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
138 if typing.TYPE_CHECKING: |
46683
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
139 from . import ( |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
140 localrepo, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
141 ui as uimod, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
142 ) |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
143 |
51302
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
144 # keeps pyflakes happy |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
145 assert [uimod] |
9d3721552b6c
pytype: import typing directly
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51122
diff
changeset
|
146 |
46683
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
147 Phasedefaults = List[ |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
148 Callable[[localrepo.localrepository, Phaseroots], Phaseroots] |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
149 ] |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
150 |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
151 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
152 _fphasesentry = struct.Struct(b'>i20s') |
34326
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
153 |
39324
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39320
diff
changeset
|
154 # record phase index |
51305
8b2ea2246a5f
pytype: convert type comment for inline variable too
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51304
diff
changeset
|
155 public: int = 0 |
8b2ea2246a5f
pytype: convert type comment for inline variable too
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51304
diff
changeset
|
156 draft: int = 1 |
8b2ea2246a5f
pytype: convert type comment for inline variable too
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51304
diff
changeset
|
157 secret: int = 2 |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
158 archived = 32 # non-continuous for compatibility |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
159 internal = 96 # non-continuous for compatibility |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
160 allphases = (public, draft, secret, archived, internal) |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
161 trackedphases = (draft, secret, archived, internal) |
50421
92f71d40fc1d
revset: include all non-public phases in _notpublic
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49475
diff
changeset
|
162 not_public_phases = trackedphases |
39324
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39320
diff
changeset
|
163 # record phase names |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
164 cmdphasenames = [b'public', b'draft', b'secret'] # known to `hg phase` command |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
165 phasenames = dict(enumerate(cmdphasenames)) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
166 phasenames[archived] = b'archived' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
167 phasenames[internal] = b'internal' |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
168 # map phase name to phase number |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
169 phasenumber = {name: phase for phase, name in phasenames.items()} |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
170 # like phasenumber, but also include maps for the numeric and binary |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
171 # phase number to the phase number |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
172 phasenumber2 = phasenumber.copy() |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
173 phasenumber2.update({phase: phase for phase in phasenames}) |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
174 phasenumber2.update({b'%i' % phase: phase for phase in phasenames}) |
39324
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39320
diff
changeset
|
175 # record phase property |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
176 mutablephases = (draft, secret, archived, internal) |
51122
80bda4254b84
unstable: do not consider internal phases when computing unstable
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50952
diff
changeset
|
177 relevant_mutable_phases = (draft, secret) # could be obsolete or unstable |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
178 remotehiddenphases = (secret, archived, internal) |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
179 localhiddenphases = (internal, archived) |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
180 |
50430
386737600689
revset: add `_internal()` predicate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50426
diff
changeset
|
181 all_internal_phases = tuple(p for p in allphases if p & internal) |
386737600689
revset: add `_internal()` predicate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50426
diff
changeset
|
182 # We do not want any internal content to exit the repository, ever. |
386737600689
revset: add `_internal()` predicate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50426
diff
changeset
|
183 no_bundle_phases = all_internal_phases |
386737600689
revset: add `_internal()` predicate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50426
diff
changeset
|
184 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
185 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
186 def supportinternal(repo: "localrepo.localrepository") -> bool: |
39326
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39324
diff
changeset
|
187 """True if the internal phase can be used on a repository""" |
45392
77b8588dd84e
requirements: introduce new requirements related module
Pulkit Goyal <7895pulkit@gmail.com>
parents:
45376
diff
changeset
|
188 return requirements.INTERNAL_PHASE_REQUIREMENT in repo.requirements |
39326
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39324
diff
changeset
|
189 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
190 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
191 def supportarchived(repo: "localrepo.localrepository") -> bool: |
49474
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49314
diff
changeset
|
192 """True if the archived phase can be used on a repository""" |
49475
0c70d888a484
phase: introduce a dedicated requirement for the `archived` phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49474
diff
changeset
|
193 return requirements.ARCHIVED_PHASE_REQUIREMENT in repo.requirements |
49474
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49314
diff
changeset
|
194 |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49314
diff
changeset
|
195 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
196 def _readroots( |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
197 repo: "localrepo.localrepository", |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
198 phasedefaults: Optional["Phasedefaults"] = None, |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
199 ) -> Tuple[Phaseroots, bool]: |
16625
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
200 """Read phase roots from disk |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
201 |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
202 phasedefaults is a list of fn(repo, roots) callable, which are |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
203 executed if the phase roots file does not exist. When phases are |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
204 being initialized on an existing repository, this could be used to |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
205 set selected changesets phase to something else than public. |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
206 |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
207 Return (roots, dirty) where dirty is true if roots differ from |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
208 what is being stored. |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
209 """ |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
210 repo = repo.unfiltered() |
16625
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
211 dirty = False |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
212 roots = {i: set() for i in allphases} |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
213 to_rev = repo.changelog.index.get_rev |
51403
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
214 unknown_msg = b'removing unknown node %s from %i-phase boundary\n' |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
215 try: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
216 f, pending = txnutil.trypending(repo.root, repo.svfs, b'phaseroots') |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
217 try: |
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
218 for line in f: |
51403
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
219 str_phase, hex_node = line.split() |
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
220 phase = int(str_phase) |
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
221 node = bin(hex_node) |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
222 rev = to_rev(node) |
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
223 if rev is None: |
51403
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
224 repo.ui.debug(unknown_msg % (short(hex_node), phase)) |
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
225 dirty = True |
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
226 else: |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
227 roots[phase].add(rev) |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
228 finally: |
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
229 f.close() |
49314
2e726c934fcd
py3: catch FileNotFoundError instead of checking errno == ENOENT
Manuel Jacob <me@manueljacob.de>
parents:
49292
diff
changeset
|
230 except FileNotFoundError: |
16625
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
231 if phasedefaults: |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
232 for f in phasedefaults: |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
233 roots = f(repo, roots) |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
234 dirty = True |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
235 return roots, dirty |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
236 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
237 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
238 def binaryencode(phasemapping: Dict[int, List[bytes]]) -> bytes: |
34326
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
239 """encode a 'phase -> nodes' mapping into a binary stream |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
240 |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
241 The revision lists are encoded as (phase, root) pairs. |
34326
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
242 """ |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
243 binarydata = [] |
49004
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48966
diff
changeset
|
244 for phase, nodes in phasemapping.items(): |
34326
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
245 for head in nodes: |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
246 binarydata.append(_fphasesentry.pack(phase, head)) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
247 return b''.join(binarydata) |
34326
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
248 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
249 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
250 def binarydecode(stream) -> Dict[int, List[bytes]]: |
34327
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
251 """decode a binary stream into a 'phase -> nodes' mapping |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
252 |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
253 The (phase, root) pairs are turned back into a dictionary with |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
254 the phase as index and the aggregated roots of that phase as value.""" |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
255 headsbyphase = {i: [] for i in allphases} |
34327
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
256 entrysize = _fphasesentry.size |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
257 while True: |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
258 entry = stream.read(entrysize) |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
259 if len(entry) < entrysize: |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
260 if entry: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
261 raise error.Abort(_(b'bad phase-heads stream')) |
34327
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
262 break |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
263 phase, node = _fphasesentry.unpack(entry) |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
264 headsbyphase[phase].append(node) |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
265 return headsbyphase |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34326
diff
changeset
|
266 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
267 |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
268 def _sortedrange_insert(data, idx, rev, t): |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
269 merge_before = False |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
270 if idx: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
271 r1, t1 = data[idx - 1] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
272 merge_before = r1[-1] + 1 == rev and t1 == t |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
273 merge_after = False |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
274 if idx < len(data): |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
275 r2, t2 = data[idx] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
276 merge_after = r2[0] == rev + 1 and t2 == t |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
277 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
278 if merge_before and merge_after: |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
279 data[idx - 1] = (range(r1[0], r2[-1] + 1), t) |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
280 data.pop(idx) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
281 elif merge_before: |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
282 data[idx - 1] = (range(r1[0], rev + 1), t) |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
283 elif merge_after: |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
284 data[idx] = (range(rev, r2[-1] + 1), t) |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
285 else: |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
286 data.insert(idx, (range(rev, rev + 1), t)) |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
287 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
288 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
289 def _sortedrange_split(data, idx, rev, t): |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
290 r1, t1 = data[idx] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
291 if t == t1: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
292 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
293 t = (t1[0], t[1]) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
294 if len(r1) == 1: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
295 data.pop(idx) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
296 _sortedrange_insert(data, idx, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
297 elif r1[0] == rev: |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
298 data[idx] = (range(rev + 1, r1[-1] + 1), t1) |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
299 _sortedrange_insert(data, idx, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
300 elif r1[-1] == rev: |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
301 data[idx] = (range(r1[0], rev), t1) |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
302 _sortedrange_insert(data, idx + 1, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
303 else: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
304 data[idx : idx + 1] = [ |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
305 (range(r1[0], rev), t1), |
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
306 (range(rev, rev + 1), t), |
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
307 (range(rev + 1, r1[-1] + 1), t1), |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
308 ] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
309 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
310 |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
311 def _trackphasechange(data, rev, old, new): |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
312 """add a phase move to the <data> list of ranges |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
313 |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
314 If data is None, nothing happens. |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
315 """ |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
316 if data is None: |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
317 return |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
318 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
319 # If data is empty, create a one-revision range and done |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
320 if not data: |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
321 data.insert(0, (range(rev, rev + 1), (old, new))) |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
322 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
323 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
324 low = 0 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
325 high = len(data) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
326 t = (old, new) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
327 while low < high: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
328 mid = (low + high) // 2 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
329 revs = data[mid][0] |
45556
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45392
diff
changeset
|
330 revs_low = revs[0] |
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45392
diff
changeset
|
331 revs_high = revs[-1] |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
332 |
45556
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45392
diff
changeset
|
333 if rev >= revs_low and rev <= revs_high: |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
334 _sortedrange_split(data, mid, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
335 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
336 |
45556
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45392
diff
changeset
|
337 if revs_low == rev + 1: |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
338 if mid and data[mid - 1][0][-1] == rev: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
339 _sortedrange_split(data, mid - 1, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
340 else: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
341 _sortedrange_insert(data, mid, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
342 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
343 |
45556
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45392
diff
changeset
|
344 if revs_high == rev - 1: |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
345 if mid + 1 < len(data) and data[mid + 1][0][0] == rev: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
346 _sortedrange_split(data, mid + 1, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
347 else: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
348 _sortedrange_insert(data, mid + 1, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
349 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
350 |
45556
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45392
diff
changeset
|
351 if revs_low > rev: |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
352 high = mid |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
353 else: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
354 low = mid + 1 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
355 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
356 if low == len(data): |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
357 data.append((range(rev, rev + 1), t)) |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
358 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
359 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
360 r1, t1 = data[low] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
361 if r1[0] > rev: |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
362 data.insert(low, (range(rev, rev + 1), t)) |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
363 else: |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
364 data.insert(low + 1, (range(rev, rev + 1), t)) |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
365 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
366 |
49037
642e31cb55f0
py3: use class X: instead of class X(object):
Gregory Szorc <gregory.szorc@gmail.com>
parents:
49004
diff
changeset
|
367 class phasecache: |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
368 def __init__( |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
369 self, |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
370 repo: "localrepo.localrepository", |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
371 phasedefaults: Optional["Phasedefaults"], |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
372 _load: bool = True, |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
373 ): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
374 if _load: |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
375 # Cheap trick to allow shallow-copy without copy module |
51403
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
376 loaded = _readroots(repo, phasedefaults) |
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
377 self._phaseroots: Phaseroots = loaded[0] |
12881244e48a
phases: do filtering at read time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51402
diff
changeset
|
378 self.dirty: bool = loaded[1] |
35446
56745e58df07
phases: initialize number of loaded revisions to 0
Yuya Nishihara <yuya@tcha.org>
parents:
35445
diff
changeset
|
379 self._loadedrevslen = 0 |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24599
diff
changeset
|
380 self._phasesets = None |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
381 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
382 def hasnonpublicphases(self, repo: "localrepo.localrepository") -> bool: |
45114
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
383 """detect if there are revisions with non-public phase""" |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
384 repo = repo.unfiltered() |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
385 cl = repo.changelog |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
386 if len(cl) >= self._loadedrevslen: |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
387 self.invalidate() |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
388 self.loadphaserevs(repo) |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
389 return any( |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
390 revs for phase, revs in self._phaseroots.items() if phase != public |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
391 ) |
45114
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
392 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
393 def nonpublicphaseroots( |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
394 self, repo: "localrepo.localrepository" |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
395 ) -> Set[int]: |
45114
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
396 """returns the roots of all non-public phases |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
397 |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
398 The roots are not minimized, so if the secret revisions are |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
399 descendants of draft revisions, their roots will still be present. |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
400 """ |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
401 repo = repo.unfiltered() |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
402 cl = repo.changelog |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
403 if len(cl) >= self._loadedrevslen: |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
404 self.invalidate() |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
405 self.loadphaserevs(repo) |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
406 return set().union( |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
407 *[ |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
408 revs |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
409 for phase, revs in self._phaseroots.items() |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
410 if phase != public |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
411 ] |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
412 ) |
45114
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45064
diff
changeset
|
413 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
414 def getrevset( |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
415 self, |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
416 repo: "localrepo.localrepository", |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
417 phases: Iterable[int], |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
418 subset: Optional[Any] = None, |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
419 ) -> Any: |
46683
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45813
diff
changeset
|
420 # TODO: finish typing this |
31036
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30639
diff
changeset
|
421 """return a smartset for the given phases""" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
422 self.loadphaserevs(repo) # ensure phase's sets are loaded |
35318
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
423 phases = set(phases) |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
424 publicphase = public in phases |
44007
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43763
diff
changeset
|
425 |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
426 if publicphase: |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
427 # In this case, phases keeps all the *other* phases. |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
428 phases = set(allphases).difference(phases) |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
429 if not phases: |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
430 return smartset.fullreposet(repo) |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
431 |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
432 # fast path: _phasesets contains the interesting sets, |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
433 # might only need a union and post-filtering. |
44065
ab41dad7345e
phases: make phasecache._phasesets immutable
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44064
diff
changeset
|
434 revsneedscopy = False |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
435 if len(phases) == 1: |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
436 [p] = phases |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
437 revs = self._phasesets[p] |
44065
ab41dad7345e
phases: make phasecache._phasesets immutable
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44064
diff
changeset
|
438 revsneedscopy = True # Don't modify _phasesets |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
439 else: |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
440 # revs has the revisions in all *other* phases. |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
441 revs = set.union(*[self._phasesets[p] for p in phases]) |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
442 |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
443 def _addwdir(wdirsubset, wdirrevs): |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
444 if wdirrev in wdirsubset and repo[None].phase() in phases: |
44065
ab41dad7345e
phases: make phasecache._phasesets immutable
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44064
diff
changeset
|
445 if revsneedscopy: |
ab41dad7345e
phases: make phasecache._phasesets immutable
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44064
diff
changeset
|
446 wdirrevs = wdirrevs.copy() |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
447 # The working dir would never be in the # cache, but it was in |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
448 # the subset being filtered for its phase (or filtered out, |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
449 # depending on publicphase), so add it to the output to be |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
450 # included (or filtered out). |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
451 wdirrevs.add(wdirrev) |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
452 return wdirrevs |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
453 |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
454 if not publicphase: |
31036
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30639
diff
changeset
|
455 if repo.changelog.filteredrevs: |
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30639
diff
changeset
|
456 revs = revs - repo.changelog.filteredrevs |
44007
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43763
diff
changeset
|
457 |
35339
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35318
diff
changeset
|
458 if subset is None: |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35318
diff
changeset
|
459 return smartset.baseset(revs) |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35318
diff
changeset
|
460 else: |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
461 revs = _addwdir(subset, revs) |
35339
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35318
diff
changeset
|
462 return subset & smartset.baseset(revs) |
31036
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30639
diff
changeset
|
463 else: |
35339
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35318
diff
changeset
|
464 if subset is None: |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35318
diff
changeset
|
465 subset = smartset.fullreposet(repo) |
44007
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43763
diff
changeset
|
466 |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44007
diff
changeset
|
467 revs = _addwdir(subset, revs) |
44007
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43763
diff
changeset
|
468 |
35318
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
469 if not revs: |
35339
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35318
diff
changeset
|
470 return subset |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35318
diff
changeset
|
471 return subset.filter(lambda r: r not in revs) |
31036
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30639
diff
changeset
|
472 |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
473 def copy(self): |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
474 # Shallow copy meant to ensure isolation in |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
475 # advance/retractboundary(), nothing more. |
23631
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
23361
diff
changeset
|
476 ph = self.__class__(None, None, _load=False) |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
477 ph._phaseroots = self._phaseroots.copy() |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
478 ph.dirty = self.dirty |
35445
98cc121099fe
phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents:
35339
diff
changeset
|
479 ph._loadedrevslen = self._loadedrevslen |
25592
dd2349ccfa66
phase: also copy phase's sets when copying phase cache
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25527
diff
changeset
|
480 ph._phasesets = self._phasesets |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
481 return ph |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
482 |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
483 def replace(self, phcache): |
25613
a13c18c14ade
phase: document the replace method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25611
diff
changeset
|
484 """replace all values in 'self' with content of phcache""" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
485 for a in ( |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
486 '_phaseroots', |
50623
0f83dc22efbc
safehasattr: pass attribute name as string instead of bytes
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50430
diff
changeset
|
487 'dirty', |
0f83dc22efbc
safehasattr: pass attribute name as string instead of bytes
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50430
diff
changeset
|
488 '_loadedrevslen', |
0f83dc22efbc
safehasattr: pass attribute name as string instead of bytes
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50430
diff
changeset
|
489 '_phasesets', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
490 ): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
491 setattr(self, a, getattr(phcache, a)) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
492 |
24599
2a73829ebe17
phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24520
diff
changeset
|
493 def _getphaserevsnative(self, repo): |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
494 repo = repo.unfiltered() |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
495 return repo.changelog.computephases(self._phaseroots) |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
496 |
24599
2a73829ebe17
phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24520
diff
changeset
|
497 def _computephaserevspure(self, repo): |
24519
de3acfabaddc
phases: move pure phase computation in a function
Laurent Charignon <lcharignon@fb.com>
parents:
24444
diff
changeset
|
498 repo = repo.unfiltered() |
35318
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
499 cl = repo.changelog |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
500 self._phasesets = {phase: set() for phase in allphases} |
39298
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39290
diff
changeset
|
501 lowerroots = set() |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39290
diff
changeset
|
502 for phase in reversed(trackedphases): |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
503 roots = self._phaseroots[phase] |
39298
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39290
diff
changeset
|
504 if roots: |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39290
diff
changeset
|
505 ps = set(cl.descendants(roots)) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39290
diff
changeset
|
506 for root in roots: |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39290
diff
changeset
|
507 ps.add(root) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39290
diff
changeset
|
508 ps.difference_update(lowerroots) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39290
diff
changeset
|
509 lowerroots.update(ps) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39290
diff
changeset
|
510 self._phasesets[phase] = ps |
35445
98cc121099fe
phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents:
35339
diff
changeset
|
511 self._loadedrevslen = len(cl) |
24519
de3acfabaddc
phases: move pure phase computation in a function
Laurent Charignon <lcharignon@fb.com>
parents:
24444
diff
changeset
|
512 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
513 def loadphaserevs(self, repo: "localrepo.localrepository") -> None: |
25611
d89045a66e01
phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25594
diff
changeset
|
514 """ensure phase information is loaded in the object""" |
35318
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
515 if self._phasesets is None: |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
516 try: |
31162
b7cef987356d
phases: remove experimental.nativephaseskillswitch
Jun Wu <quark@fb.com>
parents:
31073
diff
changeset
|
517 res = self._getphaserevsnative(repo) |
35445
98cc121099fe
phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents:
35339
diff
changeset
|
518 self._loadedrevslen, self._phasesets = res |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
519 except AttributeError: |
24599
2a73829ebe17
phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24520
diff
changeset
|
520 self._computephaserevspure(repo) |
22894
c40be72dc177
phases: move root phase assignment to it's own function
Durham Goode <durham@fb.com>
parents:
22893
diff
changeset
|
521 |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
522 def invalidate(self): |
35446
56745e58df07
phases: initialize number of loaded revisions to 0
Yuya Nishihara <yuya@tcha.org>
parents:
35445
diff
changeset
|
523 self._loadedrevslen = 0 |
25593
9e551f155810
phase: invalidate the phase's set cache alongside the revs
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25592
diff
changeset
|
524 self._phasesets = None |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
525 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
526 def phase(self, repo: "localrepo.localrepository", rev: int) -> int: |
35318
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
527 # We need a repo argument here to be able to build _phasesets |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
528 # if necessary. The repository instance is not stored in |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
529 # phasecache to avoid reference cycles. The changelog instance |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
530 # is not stored because it is a filecache() property and can |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
531 # be replaced without us being notified. |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
532 if rev == nullrev: |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
533 return public |
19984
7d5e7799a29f
rebase: fix rebase aborts when 'tip-1' is public (issue4082)
Durham Goode <durham@fb.com>
parents:
19951
diff
changeset
|
534 if rev < nullrev: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
535 raise ValueError(_(b'cannot lookup negative revision')) |
35445
98cc121099fe
phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents:
35339
diff
changeset
|
536 if rev >= self._loadedrevslen: |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
537 self.invalidate() |
25611
d89045a66e01
phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25594
diff
changeset
|
538 self.loadphaserevs(repo) |
35318
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
539 for phase in trackedphases: |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
540 if rev in self._phasesets[phase]: |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
541 return phase |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
542 return public |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
543 |
51402
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
544 def write(self, repo): |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
545 if not self.dirty: |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
546 return |
51402
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
547 f = repo.svfs(b'phaseroots', b'w', atomictemp=True, checkambig=True) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
548 try: |
51402
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
549 self._write(repo.unfiltered(), f) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
550 finally: |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
551 f.close() |
22079
5dcc58649b1a
phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22070
diff
changeset
|
552 |
51402
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
553 def _write(self, repo, fp): |
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
554 assert repo.filtername is None |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
555 to_node = repo.changelog.node |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
556 for phase, roots in self._phaseroots.items(): |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
557 for r in sorted(roots): |
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
558 h = to_node(r) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
559 fp.write(b'%i %s\n' % (phase, hex(h))) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
560 self.dirty = False |
15454
5a7dde5adec8
phases: add a moveboundary function to move phases boundaries
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15419
diff
changeset
|
561 |
51402
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
562 def _updateroots(self, repo, phase, newroots, tr): |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
563 self._phaseroots[phase] = newroots |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
564 self.invalidate() |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
565 self.dirty = True |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
566 |
51402
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
567 assert repo.filtername is None |
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
568 wrepo = weakref.ref(repo) |
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
569 |
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
570 def tr_write(fp): |
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
571 repo = wrepo() |
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
572 assert repo is not None |
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
573 self._write(repo, fp) |
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
574 |
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
575 tr.addfilegenerator(b'phase', (b'phaseroots',), tr_write) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
576 tr.hookargs[b'phases_moved'] = b'1' |
22080
37f46575d9c2
phase: attach phase to the transaction instead of the lock
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22079
diff
changeset
|
577 |
45813
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45812
diff
changeset
|
578 def registernew(self, repo, tr, targetphase, revs): |
33453
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
579 repo = repo.unfiltered() |
45813
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45812
diff
changeset
|
580 self._retractboundary(repo, tr, targetphase, [], revs=revs) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
581 if tr is not None and b'phases' in tr.changes: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
582 phasetracking = tr.changes[b'phases'] |
33453
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
583 phase = self.phase |
45813
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45812
diff
changeset
|
584 for rev in sorted(revs): |
33453
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
585 revphase = phase(repo, rev) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
586 _trackphasechange(phasetracking, rev, None, revphase) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
587 repo.invalidatevolatilesets() |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
588 |
45812
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
589 def advanceboundary( |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
590 self, repo, tr, targetphase, nodes=None, revs=None, dryrun=None |
45812
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
591 ): |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
592 """Set all 'nodes' to phase 'targetphase' |
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
593 |
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
594 Nodes with a phase lower than 'targetphase' are not affected. |
38230
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
595 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
596 If dryrun is True, no actions will be performed |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
597 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
598 Returns a set of revs whose phase is changed or should be changed |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
599 """ |
51406
330d74750668
phases: fast path public phase advance when everything is public
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51405
diff
changeset
|
600 if targetphase == public and not self.hasnonpublicphases(repo): |
330d74750668
phases: fast path public phase advance when everything is public
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51405
diff
changeset
|
601 return set() |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
602 # Be careful to preserve shallow-copied values: do not update |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
603 # phaseroots values, replace them. |
45812
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
604 if revs is None: |
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
605 revs = [] |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
606 if not revs and not nodes: |
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
607 return set() |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
608 if tr is None: |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
609 phasetracking = None |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
610 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
611 phasetracking = tr.changes.get(b'phases') |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
612 |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
613 repo = repo.unfiltered() |
45812
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
614 revs = [repo[n].rev() for n in nodes] + [r for r in revs] |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
615 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
616 changes = set() # set of revisions to be changed |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
617 delroots = [] # set of root deleted by this path |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
618 for phase in (phase for phase in allphases if phase > targetphase): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
619 # filter nodes that are not in a compatible phase already |
45812
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
620 revs = [rev for rev in revs if self.phase(repo, rev) >= phase] |
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
621 if not revs: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
622 break # no roots to move anymore |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
623 |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
624 olds = self._phaseroots[phase] |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
625 |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
626 affected = repo.revs(b'%ld::%ld', olds, revs) |
38230
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
627 changes.update(affected) |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
628 if dryrun: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
629 continue |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
630 for r in affected: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
631 _trackphasechange( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
632 phasetracking, r, self.phase(repo, r), targetphase |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
633 ) |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
634 |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
635 roots = set(repo.revs(b'roots((%ld::) - %ld)', olds, affected)) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
636 if olds != roots: |
51402
04111ef08fb0
phases: always write with a repo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51401
diff
changeset
|
637 self._updateroots(repo, phase, roots, tr) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
638 # some roots may need to be declared for lower phases |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
639 delroots.extend(olds - roots) |
38230
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
640 if not dryrun: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
641 # declare deleted root in the target phase |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
642 if targetphase != 0: |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
643 self._retractboundary(repo, tr, targetphase, revs=delroots) |
38230
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
644 repo.invalidatevolatilesets() |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
645 return changes |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
646 |
22070
c1ca47204590
phase: add a transaction argument to retractboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22069
diff
changeset
|
647 def retractboundary(self, repo, tr, targetphase, nodes): |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
648 oldroots = { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
649 phase: revs |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
650 for phase, revs in self._phaseroots.items() |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
651 if phase <= targetphase |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
652 } |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
653 if tr is None: |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
654 phasetracking = None |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
655 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
656 phasetracking = tr.changes.get(b'phases') |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
657 repo = repo.unfiltered() |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
658 retracted = self._retractboundary(repo, tr, targetphase, nodes) |
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
659 if retracted and phasetracking is not None: |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
660 |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
661 # find the affected revisions |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
662 new = self._phaseroots[targetphase] |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
663 old = oldroots[targetphase] |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
664 affected = set(repo.revs(b'(%ld::) - (%ld::)', new, old)) |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
665 |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
666 # find the phase of the affected revision |
49292
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
49037
diff
changeset
|
667 for phase in range(targetphase, -1, -1): |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
668 if phase: |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
669 roots = oldroots.get(phase, []) |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
670 revs = set(repo.revs(b'%ld::%ld', roots, affected)) |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
671 affected -= revs |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
672 else: # public phase |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
673 revs = affected |
44558
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44470
diff
changeset
|
674 for r in sorted(revs): |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
675 _trackphasechange(phasetracking, r, phase, targetphase) |
33452
7b25a56366cf
phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33451
diff
changeset
|
676 repo.invalidatevolatilesets() |
7b25a56366cf
phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33451
diff
changeset
|
677 |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
678 def _retractboundary(self, repo, tr, targetphase, nodes=None, revs=None): |
51405
71ae6fee2b9d
phases: fast path retract of public phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51404
diff
changeset
|
679 if targetphase == public: |
51407
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
680 return {} |
49474
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49314
diff
changeset
|
681 if ( |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49314
diff
changeset
|
682 targetphase == internal |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49314
diff
changeset
|
683 and not supportinternal(repo) |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49314
diff
changeset
|
684 or targetphase == archived |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49314
diff
changeset
|
685 and not supportarchived(repo) |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49314
diff
changeset
|
686 ): |
40408
49c7b701fdc2
phase: add an archived phase
Boris Feld <boris.feld@octobus.net>
parents:
39326
diff
changeset
|
687 name = phasenames[targetphase] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
688 msg = b'this repository does not support the %s phase' % name |
39326
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39324
diff
changeset
|
689 raise error.ProgrammingError(msg) |
51407
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
690 assert repo.filtername is None |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
691 cl = repo.changelog |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
692 torev = cl.index.rev |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
693 new_revs = set() |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
694 if revs is not None: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
695 new_revs.update(revs) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
696 if nodes is not None: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
697 new_revs.update(torev(node) for node in nodes) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
698 if not new_revs: # bail out early to avoid the loadphaserevs call |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
699 return {} # note: why do people call retractboundary with nothing ? |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
700 |
51407
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
701 if nullrev in new_revs: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
702 raise error.Abort(_(b'cannot change null revision phase')) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
703 |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
704 # Compute change in phase roots by walking the graph |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
705 # |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
706 # note: If we had a cheap parent → children mapping we could do |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
707 # something even cheaper/more-bounded |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
708 # |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
709 # The idea would be to walk from item in new_revs stopping at |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
710 # descendant with phases >= target_phase. |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
711 # |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
712 # 1) This detect new_revs that are not new_roots (either already >= |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
713 # target_phase or reachable though another new_revs |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
714 # 2) This detect replaced current_roots as we reach them |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
715 # 3) This can avoid walking to the tip if we retract over a small |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
716 # branch. |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
717 # |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
718 # So instead, we do a variation of this, we walk from the smaller new |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
719 # revision to the tip to avoid missing any potential children. |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
720 # |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
721 # The following code would be a good candidate for native code… if only |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
722 # we could knew the phase of a changeset efficiently in native code. |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
723 parents = cl.parentrevs |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
724 phase = self.phase |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
725 new_roots = set() # roots added by this phases |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
726 changed_revs = {} # revision affected by this call |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
727 replaced_roots = set() # older roots replaced by this call |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
728 currentroots = self._phaseroots[targetphase] |
51407
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
729 start = min(new_revs) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
730 end = len(cl) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
731 rev_phases = [None] * (end - start) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
732 for r in range(start, end): |
45008
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44558
diff
changeset
|
733 |
51407
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
734 # gather information about the current_rev |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
735 r_phase = phase(repo, r) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
736 p_phase = None # phase inherited from parents |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
737 p1, p2 = parents(r) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
738 if p1 >= start: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
739 p1_phase = rev_phases[p1 - start] |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
740 if p1_phase is not None: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
741 p_phase = p1_phase |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
742 if p2 >= start: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
743 p2_phase = rev_phases[p2 - start] |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
744 if p2_phase is not None: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
745 if p_phase is not None: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
746 p_phase = max(p_phase, p2_phase) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
747 else: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
748 p_phase = p2_phase |
26909
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
749 |
51407
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
750 # assess the situation |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
751 if r in new_revs and r_phase < targetphase: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
752 if p_phase is None or p_phase < targetphase: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
753 new_roots.add(r) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
754 rev_phases[r - start] = targetphase |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
755 changed_revs[r] = r_phase |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
756 elif p_phase is None: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
757 rev_phases[r - start] = r_phase |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
758 else: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
759 if p_phase > r_phase: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
760 rev_phases[r - start] = p_phase |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
761 else: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
762 rev_phases[r - start] = r_phase |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
763 if p_phase == targetphase: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
764 if p_phase > r_phase: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
765 changed_revs[r] = r_phase |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
766 elif r in currentroots: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
767 replaced_roots.add(r) |
26909
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
768 |
51407
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
769 if new_roots: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
770 assert changed_revs |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
771 final_roots = new_roots | currentroots - replaced_roots |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
772 self._updateroots(repo, targetphase, final_roots, tr) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
773 if targetphase > 1: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
774 retracted = set(changed_revs) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
775 for lower_phase in range(1, targetphase): |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
776 lower_roots = self._phaseroots.get(lower_phase) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
777 if lower_roots is None: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
778 continue |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
779 if lower_roots & retracted: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
780 simpler_roots = lower_roots - retracted |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
781 self._updateroots(repo, lower_phase, simpler_roots, tr) |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
782 return changed_revs |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
783 else: |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
784 assert not changed_revs |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
785 assert not replaced_roots |
2f39c7aeb549
phases: large rewrite on retract boundary
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51406
diff
changeset
|
786 return {} |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
787 |
51399
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
788 def register_strip( |
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
789 self, |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
790 repo, |
51399
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
791 tr, |
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
792 strip_rev: int, |
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
793 ): |
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
794 """announce a strip to the phase cache |
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
795 |
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
796 Any roots higher than the stripped revision should be dropped. |
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
797 """ |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
798 for targetphase, roots in list(self._phaseroots.items()): |
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
799 filtered = {r for r in roots if r >= strip_rev} |
51399
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
800 if filtered: |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
801 self._updateroots(repo, targetphase, roots - filtered, tr) |
51399
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
802 self.invalidate() |
8f2ea3fa50fd
phases: explicitly filter stripped revision at strip time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51307
diff
changeset
|
803 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
804 |
45812
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
805 def advanceboundary(repo, tr, targetphase, nodes, revs=None, dryrun=None): |
15454
5a7dde5adec8
phases: add a moveboundary function to move phases boundaries
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15419
diff
changeset
|
806 """Add nodes to a phase changing other nodes phases if necessary. |
5a7dde5adec8
phases: add a moveboundary function to move phases boundaries
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15419
diff
changeset
|
807 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
808 This function move boundary *forward* this means that all nodes |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
809 are set in the target phase or kept in a *lower* phase. |
15454
5a7dde5adec8
phases: add a moveboundary function to move phases boundaries
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15419
diff
changeset
|
810 |
38230
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
811 Simplify boundary to contains phase roots only. |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
812 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
813 If dryrun is True, no actions will be performed |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
814 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
815 Returns a set of revs whose phase is changed or should be changed |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
816 """ |
45812
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
817 if revs is None: |
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
818 revs = [] |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
819 phcache = repo._phasecache.copy() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
820 changes = phcache.advanceboundary( |
45812
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45556
diff
changeset
|
821 repo, tr, targetphase, nodes, revs=revs, dryrun=dryrun |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
822 ) |
38230
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
823 if not dryrun: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
824 repo._phasecache.replace(phcache) |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38191
diff
changeset
|
825 return changes |
15482
a667c89e49b3
phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15481
diff
changeset
|
826 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
827 |
22070
c1ca47204590
phase: add a transaction argument to retractboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22069
diff
changeset
|
828 def retractboundary(repo, tr, targetphase, nodes): |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
829 """Set nodes back to a phase changing other nodes phases if |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
830 necessary. |
15482
a667c89e49b3
phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15481
diff
changeset
|
831 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
832 This function move boundary *backward* this means that all nodes |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
833 are set in the target phase or kept in a *higher* phase. |
15482
a667c89e49b3
phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15481
diff
changeset
|
834 |
a667c89e49b3
phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15481
diff
changeset
|
835 Simplify boundary to contains phase roots only.""" |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
836 phcache = repo._phasecache.copy() |
22070
c1ca47204590
phase: add a transaction argument to retractboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22069
diff
changeset
|
837 phcache.retractboundary(repo, tr, targetphase, nodes) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
838 repo._phasecache.replace(phcache) |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
839 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
840 |
45813
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45812
diff
changeset
|
841 def registernew(repo, tr, targetphase, revs): |
33453
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
842 """register a new revision and its phase |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
843 |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
844 Code adding revisions to the repository should use this function to |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
845 set new changeset in their target phase (or higher). |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
846 """ |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
847 phcache = repo._phasecache.copy() |
45813
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45812
diff
changeset
|
848 phcache.registernew(repo, tr, targetphase, revs) |
33453
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
849 repo._phasecache.replace(phcache) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
850 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
851 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
852 def listphases(repo: "localrepo.localrepository") -> Dict[bytes, bytes]: |
16724
00535da82faf
phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents:
16659
diff
changeset
|
853 """List phases root for serialization over pushkey""" |
32000
511a62669f1b
phases: emit phases to pushkey protocol in deterministic order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31351
diff
changeset
|
854 # Use ordered dictionary so behavior is deterministic. |
511a62669f1b
phases: emit phases to pushkey protocol in deterministic order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31351
diff
changeset
|
855 keys = util.sortdict() |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
856 value = b'%i' % draft |
34816
e2c42f751b06
phase: filter out non-draft item in "draft root"
Boris Feld <boris.feld@octobus.net>
parents:
34710
diff
changeset
|
857 cl = repo.unfiltered().changelog |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
858 to_node = cl.node |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
859 for root in repo._phasecache._phaseroots[draft]: |
51404
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
860 if repo._phasecache.phase(repo, root) <= draft: |
f8bf1a8e9181
phases: keep internal state as rev-num instead of node-id
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51403
diff
changeset
|
861 keys[hex(to_node(root))] = value |
15892
592b3d1742a1
phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15821
diff
changeset
|
862 |
25624
f0745da75056
publishing: use new helper method
Matt Mackall <mpm@selenic.com>
parents:
25614
diff
changeset
|
863 if repo.publishing(): |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
864 # Add an extra data to let remote know we are a publishing |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
865 # repo. Publishing repo can't just pretend they are old repo. |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
866 # When pushing to a publishing repo, the client still need to |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
867 # push phase boundary |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
868 # |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
869 # Push do not only push changeset. It also push phase data. |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
870 # New phase data may apply to common changeset which won't be |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
871 # push (as they are common). Here is a very simple example: |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
872 # |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
873 # 1) repo A push changeset X as draft to repo B |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
874 # 2) repo B make changeset X public |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
875 # 3) repo B push to repo A. X is not pushed but the data that |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
876 # X as now public should |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
877 # |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
878 # The server can't handle it on it's own as it has no idea of |
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
879 # client phase data. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
880 keys[b'publishing'] = b'True' |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
881 return keys |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
882 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
883 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
884 def pushphase( |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
885 repo: "localrepo.localrepository", |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
886 nhex: bytes, |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
887 oldphasestr: bytes, |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
888 newphasestr: bytes, |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
889 ) -> bool: |
17535 | 890 """List phases root for serialization over pushkey""" |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
891 repo = repo.unfiltered() |
27861
3315a9c2019c
with: use context manager for lock in pushphase
Bryan O'Sullivan <bryano@fb.com>
parents:
26909
diff
changeset
|
892 with repo.lock(): |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
893 currentphase = repo[nhex].phase() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
894 newphase = abs(int(newphasestr)) # let's avoid negative index surprise |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
895 oldphase = abs(int(oldphasestr)) # let's avoid negative index surprise |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
896 if currentphase == oldphase and newphase < oldphase: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
897 with repo.transaction(b'pushkey-phase') as tr: |
27861
3315a9c2019c
with: use context manager for lock in pushphase
Bryan O'Sullivan <bryano@fb.com>
parents:
26909
diff
changeset
|
898 advanceboundary(repo, tr, newphase, [bin(nhex)]) |
32841
e65ff29dbeb0
pushkey: use False/True for return values from push functions
Martin von Zweigbergk <martinvonz@google.com>
parents:
32000
diff
changeset
|
899 return True |
16051
2aa5b51f310f
phases: don't complain if cset is already public on pushkey (issue3230)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
900 elif currentphase == newphase: |
2aa5b51f310f
phases: don't complain if cset is already public on pushkey (issue3230)
Matt Mackall <mpm@selenic.com>
parents:
16030
diff
changeset
|
901 # raced, but got correct result |
32841
e65ff29dbeb0
pushkey: use False/True for return values from push functions
Martin von Zweigbergk <martinvonz@google.com>
parents:
32000
diff
changeset
|
902 return True |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
903 else: |
32841
e65ff29dbeb0
pushkey: use False/True for return values from push functions
Martin von Zweigbergk <martinvonz@google.com>
parents:
32000
diff
changeset
|
904 return False |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
905 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
906 |
33043
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
907 def subsetphaseheads(repo, subset): |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
908 """Finds the phase heads for a subset of a history |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
909 |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
910 Returns a list indexed by phase number where each item is a list of phase |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
911 head nodes. |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
912 """ |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
913 cl = repo.changelog |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
914 |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
915 headsbyphase = {i: [] for i in allphases} |
50426
385a4f8056e5
bundle: include required phases when saving a bundle (issue6794)
Jason R. Coombs <jaraco@jaraco.com>, Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50421
diff
changeset
|
916 for phase in allphases: |
385a4f8056e5
bundle: include required phases when saving a bundle (issue6794)
Jason R. Coombs <jaraco@jaraco.com>, Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
50421
diff
changeset
|
917 revset = b"heads(%%ln & _phase(%d))" % phase |
33043
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
918 headsbyphase[phase] = [cl.node(r) for r in repo.revs(revset, subset)] |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
919 return headsbyphase |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
920 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
921 |
34328
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34327
diff
changeset
|
922 def updatephases(repo, trgetter, headsbyphase): |
33043
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
923 """Updates the repo with the given phase heads""" |
45116
361a7444bc41
phases: updatephases should not skip internal phase
Joerg Sonnenberger <joerg@bec.de>
parents:
45114
diff
changeset
|
924 # Now advance phase boundaries of all phases |
34328
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34327
diff
changeset
|
925 # |
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34327
diff
changeset
|
926 # run the update (and fetch transaction) only if there are actually things |
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34327
diff
changeset
|
927 # to update. This avoid creating empty transaction during no-op operation. |
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34327
diff
changeset
|
928 |
45116
361a7444bc41
phases: updatephases should not skip internal phase
Joerg Sonnenberger <joerg@bec.de>
parents:
45114
diff
changeset
|
929 for phase in allphases: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
930 revset = b'%ln - _phase(%s)' |
39320
278eb4541758
phases: simplify revset in updatephases
Boris Feld <boris.feld@octobus.net>
parents:
39302
diff
changeset
|
931 heads = [c.node() for c in repo.set(revset, headsbyphase[phase], phase)] |
34328
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34327
diff
changeset
|
932 if heads: |
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34327
diff
changeset
|
933 advanceboundary(repo, trgetter(), phase, heads) |
33043
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32841
diff
changeset
|
934 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
935 |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
936 def analyzeremotephases(repo, subset, roots): |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
937 """Compute phases heads and root in a subset of node from root dict |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
938 |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
939 * subset is heads of the subset |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
940 * roots is {<nodeid> => phase} mapping. key and value are string. |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
941 |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
942 Accept unknown element input |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
943 """ |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
944 repo = repo.unfiltered() |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
945 # build list from dictionary |
15892
592b3d1742a1
phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15821
diff
changeset
|
946 draftroots = [] |
43586
9970412d2ce3
index: use `index.has_node` in `analyzeremotephases`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43106
diff
changeset
|
947 has_node = repo.changelog.index.has_node # to filter unknown nodes |
49004
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48966
diff
changeset
|
948 for nhex, phase in roots.items(): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
949 if nhex == b'publishing': # ignore data related to publish option |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
950 continue |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
951 node = bin(nhex) |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
952 phase = int(phase) |
28174
f16b84b1e40e
phases: use constants for phase values
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27874
diff
changeset
|
953 if phase == public: |
47055
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46683
diff
changeset
|
954 if node != repo.nullid: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
955 repo.ui.warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
956 _( |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
957 b'ignoring inconsistent public root' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
958 b' from remote: %s\n' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
959 ) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
960 % nhex |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
961 ) |
28174
f16b84b1e40e
phases: use constants for phase values
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27874
diff
changeset
|
962 elif phase == draft: |
43586
9970412d2ce3
index: use `index.has_node` in `analyzeremotephases`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43106
diff
changeset
|
963 if has_node(node): |
15892
592b3d1742a1
phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15821
diff
changeset
|
964 draftroots.append(node) |
592b3d1742a1
phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15821
diff
changeset
|
965 else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
966 repo.ui.warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
967 _(b'ignoring unexpected root from remote: %i %s\n') |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
968 % (phase, nhex) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
969 ) |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
970 # compute heads |
15954
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
971 publicheads = newheads(repo, subset, draftroots) |
15892
592b3d1742a1
phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15821
diff
changeset
|
972 return publicheads, draftroots |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
973 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
974 |
49037
642e31cb55f0
py3: use class X: instead of class X(object):
Gregory Szorc <gregory.szorc@gmail.com>
parents:
49004
diff
changeset
|
975 class remotephasessummary: |
34819
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
976 """summarize phase information on the remote side |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
977 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
978 :publishing: True is the remote is publishing |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
979 :publicheads: list of remote public phase heads (nodes) |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
980 :draftheads: list of remote draft phase heads (nodes) |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
981 :draftroots: list of remote draft phase root (nodes) |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
982 """ |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
983 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
984 def __init__(self, repo, remotesubset, remoteroots): |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
985 unfi = repo.unfiltered() |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
986 self._allremoteroots = remoteroots |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
987 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
988 self.publishing = remoteroots.get(b'publishing', False) |
34819
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
989 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
990 ana = analyzeremotephases(repo, remotesubset, remoteroots) |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
991 self.publicheads, self.draftroots = ana |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
992 # Get the list of all "heads" revs draft on remote |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
993 dheads = unfi.set(b'heads(%ln::%ln)', self.draftroots, remotesubset) |
34819
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
994 self.draftheads = [c.node() for c in dheads] |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
995 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
996 |
15954
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
997 def newheads(repo, heads, roots): |
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
998 """compute new head of a subset minus another |
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
999 |
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
1000 * `heads`: define the first subset |
17425
e95ec38f86b0
fix wording and not-completely-trivial spelling errors and bad docstrings
Mads Kiilerich <mads@kiilerich.com>
parents:
17424
diff
changeset
|
1001 * `roots`: define the second we subtract from the first""" |
38773
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1002 # prevent an import cycle |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1003 # phases > dagop > patch > copies > scmutil > obsolete > obsutil > phases |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1004 from . import dagop |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1005 |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1006 repo = repo.unfiltered() |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1007 cl = repo.changelog |
43604
505a2bc53759
index: use `index.get_rev` in `phases.newheads`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43587
diff
changeset
|
1008 rev = cl.index.get_rev |
38773
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1009 if not roots: |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1010 return heads |
47055
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46683
diff
changeset
|
1011 if not heads or heads == [repo.nullid]: |
38773
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1012 return [] |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1013 # The logic operated on revisions, convert arguments early for convenience |
47055
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46683
diff
changeset
|
1014 new_heads = {rev(n) for n in heads if n != repo.nullid} |
38773
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1015 roots = [rev(n) for n in roots] |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1016 # compute the area we need to remove |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1017 affected_zone = repo.revs(b"(%ld::%ld)", roots, new_heads) |
38773
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1018 # heads in the area are no longer heads |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1019 new_heads.difference_update(affected_zone) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1020 # revisions in the area have children outside of it, |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1021 # They might be new heads |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
1022 candidates = repo.revs( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1023 b"parents(%ld + (%ld and merge())) and not null", roots, affected_zone |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
1024 ) |
38773
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1025 candidates -= affected_zone |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1026 if new_heads or candidates: |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1027 # remove candidate that are ancestors of other heads |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1028 new_heads.update(candidates) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1029 prunestart = repo.revs(b"parents(%ld) and not null", new_heads) |
38773
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1030 pruned = dagop.reachableroots(repo, candidates, prunestart) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1031 new_heads.difference_update(pruned) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1032 |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
38772
diff
changeset
|
1033 return pycompat.maplist(cl.node, sorted(new_heads)) |
16030
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
1034 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
1035 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
1036 def newcommitphase(ui: "uimod.ui") -> int: |
16030
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
1037 """helper to get the target phase of new commit |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
1038 |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
1039 Handle all possible values for the phases.new-commit options. |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
1040 |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
1041 """ |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1042 v = ui.config(b'phases', b'new-commit') |
16030
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
1043 try: |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
1044 return phasenumber2[v] |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
1045 except KeyError: |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
1046 raise error.ConfigError( |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
1047 _(b"phases.new-commit: not a valid phase name ('%s')") % v |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
1048 ) |
16030
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
1049 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
1050 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
1051 def hassecret(repo: "localrepo.localrepository") -> bool: |
17671
fdd0fc046cf1
clfilter: introduce a `hassecret` function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17537
diff
changeset
|
1052 """utility function that check if a repo have any secret changeset.""" |
51401
68289ed170c7
phases: mark `phasecache.phaseroots` private
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51399
diff
changeset
|
1053 return bool(repo._phasecache._phaseroots[secret]) |
34710
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
1054 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40627
diff
changeset
|
1055 |
51304
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
1056 def preparehookargs( |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
1057 node: bytes, |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
1058 old: Optional[int], |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
1059 new: Optional[int], |
f15cb5111a1e
pytype: move some type comment to proper annotation
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
51302
diff
changeset
|
1060 ) -> Dict[bytes, bytes]: |
34710
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
1061 if old is None: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1062 old = b'' |
34710
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
1063 else: |
34876
eb1b964b354b
phases: pass phase names to hooks instead of internal values
Kevin Bullock <kbullock+mercurial@ringworld.org>
parents:
34819
diff
changeset
|
1064 old = phasenames[old] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1065 return {b'node': node, b'oldphase': old, b'phase': phasenames[new]} |