Mercurial > hg
annotate mercurial/phases.py @ 50076:63c4e9639753
dirstate: generalize the dirstate's invalidation on transaction abort
The previous code was too specific, we should add the invalidation at next to
the `addfilegenerator` in the `write` call.
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Thu, 16 Feb 2023 02:34:54 +0100 |
parents | 0c70d888a484 |
children | 92f71d40fc1d |
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 |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
104 import struct |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
105 |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
106 from .i18n import _ |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
107 from .node import ( |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
108 bin, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
109 hex, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
110 nullrev, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
111 short, |
44004
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43730
diff
changeset
|
112 wdirrev, |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
113 ) |
43089
c59eb1560c44
py3: manually import getattr where it is needed
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43087
diff
changeset
|
114 from .pycompat import ( |
c59eb1560c44
py3: manually import getattr where it is needed
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43087
diff
changeset
|
115 getattr, |
c59eb1560c44
py3: manually import getattr where it is needed
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43087
diff
changeset
|
116 setattr, |
c59eb1560c44
py3: manually import getattr where it is needed
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43087
diff
changeset
|
117 ) |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
118 from . import ( |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
119 error, |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
120 pycompat, |
45372
77b8588dd84e
requirements: introduce new requirements related module
Pulkit Goyal <7895pulkit@gmail.com>
parents:
45356
diff
changeset
|
121 requirements, |
31016
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
122 smartset, |
31053
6afd8a87a657
phases: check HG_PENDING strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31016
diff
changeset
|
123 txnutil, |
32000
511a62669f1b
phases: emit phases to pushkey protocol in deterministic order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31342
diff
changeset
|
124 util, |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
125 ) |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
126 |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
127 if pycompat.TYPE_CHECKING: |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
128 from typing import ( |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
129 Any, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
130 Callable, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
131 Dict, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
132 Iterable, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
133 List, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
134 Optional, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
135 Set, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
136 Tuple, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
137 ) |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
138 from . import ( |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
139 localrepo, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
140 ui as uimod, |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
141 ) |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
142 |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
143 Phaseroots = Dict[int, Set[bytes]] |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
144 Phasedefaults = List[ |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
145 Callable[[localrepo.localrepository, Phaseroots], Phaseroots] |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
146 ] |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
147 |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
148 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
149 _fphasesentry = struct.Struct(b'>i20s') |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
150 |
39297
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
151 # record phase index |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
152 public, draft, secret = range(3) # type: int |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
153 archived = 32 # non-continuous for compatibility |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
154 internal = 96 # non-continuous for compatibility |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
155 allphases = (public, draft, secret, archived, internal) |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
156 trackedphases = (draft, secret, archived, internal) |
39297
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
157 # record phase names |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
158 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
|
159 phasenames = dict(enumerate(cmdphasenames)) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
160 phasenames[archived] = b'archived' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
161 phasenames[internal] = b'internal' |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
162 # map phase name to phase number |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
163 phasenumber = {name: phase for phase, name in phasenames.items()} |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
164 # 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
|
165 # phase number to the phase number |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
166 phasenumber2 = phasenumber.copy() |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
167 phasenumber2.update({phase: phase for phase in phasenames}) |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
168 phasenumber2.update({b'%i' % phase: phase for phase in phasenames}) |
39297
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
169 # record phase property |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
170 mutablephases = (draft, secret, archived, internal) |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
171 remotehiddenphases = (secret, archived, internal) |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
172 localhiddenphases = (internal, archived) |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
173 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
174 |
39299
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
175 def supportinternal(repo): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
176 # type: (localrepo.localrepository) -> bool |
39299
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
177 """True if the internal phase can be used on a repository""" |
45372
77b8588dd84e
requirements: introduce new requirements related module
Pulkit Goyal <7895pulkit@gmail.com>
parents:
45356
diff
changeset
|
178 return requirements.INTERNAL_PHASE_REQUIREMENT in repo.requirements |
39299
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
179 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
180 |
49450
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49306
diff
changeset
|
181 def supportarchived(repo): |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49306
diff
changeset
|
182 # type: (localrepo.localrepository) -> bool |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49306
diff
changeset
|
183 """True if the archived phase can be used on a repository""" |
49451
0c70d888a484
phase: introduce a dedicated requirement for the `archived` phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49450
diff
changeset
|
184 return requirements.ARCHIVED_PHASE_REQUIREMENT in repo.requirements |
49450
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49306
diff
changeset
|
185 |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49306
diff
changeset
|
186 |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
187 def _readroots(repo, phasedefaults=None): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
188 # type: (localrepo.localrepository, Optional[Phasedefaults]) -> Tuple[Phaseroots, bool] |
16625
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
189 """Read phase roots from disk |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
190 |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
191 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
|
192 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
|
193 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
|
194 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
|
195 |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
196 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
|
197 what is being stored. |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
198 """ |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
199 repo = repo.unfiltered() |
16625
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
200 dirty = False |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
201 roots = {i: set() for i in allphases} |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
202 try: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
203 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
|
204 try: |
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
205 for line in f: |
16588
72319bfd7966
phases: line.strip().split() == line.split()
Martin Geisler <mg@aragost.com>
parents:
16535
diff
changeset
|
206 phase, nh = line.split() |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
207 roots[int(phase)].add(bin(nh)) |
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
208 finally: |
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
209 f.close() |
49306
2e726c934fcd
py3: catch FileNotFoundError instead of checking errno == ENOENT
Manuel Jacob <me@manueljacob.de>
parents:
49284
diff
changeset
|
210 except FileNotFoundError: |
16625
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
211 if phasedefaults: |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
212 for f in phasedefaults: |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
213 roots = f(repo, roots) |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
214 dirty = True |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
215 return roots, dirty |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
216 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
217 |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
218 def binaryencode(phasemapping): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
219 # type: (Dict[int, List[bytes]]) -> bytes |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
220 """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
|
221 |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
222 The revision lists are encoded as (phase, root) pairs. |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
223 """ |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
224 binarydata = [] |
48913
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48875
diff
changeset
|
225 for phase, nodes in phasemapping.items(): |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
226 for head in nodes: |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
227 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
|
228 return b''.join(binarydata) |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
229 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
230 |
34320
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
231 def binarydecode(stream): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
232 # type: (...) -> Dict[int, List[bytes]] |
34320
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
233 """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:
34319
diff
changeset
|
234 |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
235 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
|
236 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
|
237 headsbyphase = {i: [] for i in allphases} |
34320
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
238 entrysize = _fphasesentry.size |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
239 while True: |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
240 entry = stream.read(entrysize) |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
241 if len(entry) < entrysize: |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
242 if entry: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
243 raise error.Abort(_(b'bad phase-heads stream')) |
34320
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
244 break |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
245 phase, node = _fphasesentry.unpack(entry) |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
246 headsbyphase[phase].append(node) |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
247 return headsbyphase |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
248 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
249 |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
250 def _sortedrange_insert(data, idx, rev, t): |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
251 merge_before = False |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
252 if idx: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
253 r1, t1 = data[idx - 1] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
254 merge_before = r1[-1] + 1 == rev and t1 == t |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
255 merge_after = False |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
256 if idx < len(data): |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
257 r2, t2 = data[idx] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
258 merge_after = r2[0] == rev + 1 and t2 == t |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
259 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
260 if merge_before and merge_after: |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
261 data[idx - 1] = (range(r1[0], r2[-1] + 1), t) |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
262 data.pop(idx) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
263 elif merge_before: |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
264 data[idx - 1] = (range(r1[0], rev + 1), t) |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
265 elif merge_after: |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
266 data[idx] = (range(rev, r2[-1] + 1), t) |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
267 else: |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
268 data.insert(idx, (range(rev, rev + 1), t)) |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
269 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
270 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
271 def _sortedrange_split(data, idx, rev, t): |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
272 r1, t1 = data[idx] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
273 if t == t1: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
274 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
275 t = (t1[0], t[1]) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
276 if len(r1) == 1: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
277 data.pop(idx) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
278 _sortedrange_insert(data, idx, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
279 elif r1[0] == rev: |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
280 data[idx] = (range(rev + 1, r1[-1] + 1), t1) |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
281 _sortedrange_insert(data, idx, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
282 elif r1[-1] == rev: |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
283 data[idx] = (range(r1[0], rev), t1) |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
284 _sortedrange_insert(data, idx + 1, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
285 else: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
286 data[idx : idx + 1] = [ |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
287 (range(r1[0], rev), t1), |
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
288 (range(rev, rev + 1), t), |
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
289 (range(rev + 1, r1[-1] + 1), t1), |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
290 ] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
291 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
292 |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
293 def _trackphasechange(data, rev, old, new): |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
294 """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
|
295 |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
296 If data is None, nothing happens. |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
297 """ |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
298 if data is None: |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
299 return |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
300 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
301 # 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:
44452
diff
changeset
|
302 if not data: |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
303 data.insert(0, (range(rev, rev + 1), (old, new))) |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
304 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
305 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
306 low = 0 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
307 high = len(data) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
308 t = (old, new) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
309 while low < high: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
310 mid = (low + high) // 2 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
311 revs = data[mid][0] |
45550
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45372
diff
changeset
|
312 revs_low = revs[0] |
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45372
diff
changeset
|
313 revs_high = revs[-1] |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
314 |
45550
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45372
diff
changeset
|
315 if rev >= revs_low and rev <= revs_high: |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
316 _sortedrange_split(data, mid, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
317 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
318 |
45550
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45372
diff
changeset
|
319 if revs_low == rev + 1: |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
320 if mid and data[mid - 1][0][-1] == rev: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
321 _sortedrange_split(data, mid - 1, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
322 else: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
323 _sortedrange_insert(data, mid, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
324 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
325 |
45550
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45372
diff
changeset
|
326 if revs_high == rev - 1: |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
327 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:
44452
diff
changeset
|
328 _sortedrange_split(data, mid + 1, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
329 else: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
330 _sortedrange_insert(data, mid + 1, rev, t) |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
331 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
332 |
45550
29a259be6424
phases: fix performance regression with Python 2
Joerg Sonnenberger <joerg@bec.de>
parents:
45372
diff
changeset
|
333 if revs_low > rev: |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
334 high = mid |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
335 else: |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
336 low = mid + 1 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
337 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
338 if low == len(data): |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
339 data.append((range(rev, rev + 1), t)) |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
340 return |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
341 |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
342 r1, t1 = data[low] |
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
343 if r1[0] > rev: |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
344 data.insert(low, (range(rev, rev + 1), t)) |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
345 else: |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
346 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
|
347 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
348 |
48946
642e31cb55f0
py3: use class X: instead of class X(object):
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48913
diff
changeset
|
349 class phasecache: |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
350 def __init__(self, repo, phasedefaults, _load=True): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
351 # type: (localrepo.localrepository, Optional[Phasedefaults], bool) -> None |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
352 if _load: |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
353 # Cheap trick to allow shallow-copy without copy module |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
354 self.phaseroots, self.dirty = _readroots(repo, phasedefaults) |
35442
56745e58df07
phases: initialize number of loaded revisions to 0
Yuya Nishihara <yuya@tcha.org>
parents:
35441
diff
changeset
|
355 self._loadedrevslen = 0 |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24599
diff
changeset
|
356 self._phasesets = None |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
357 self.filterunknown(repo) |
23878
37a92908a382
localrepo: remove all external users of localrepo.sopener
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
23631
diff
changeset
|
358 self.opener = repo.svfs |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
359 |
45114
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
360 def hasnonpublicphases(self, repo): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
361 # type: (localrepo.localrepository) -> bool |
45114
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
362 """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:
45063
diff
changeset
|
363 repo = repo.unfiltered() |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
364 cl = repo.changelog |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
365 if len(cl) >= self._loadedrevslen: |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
366 self.invalidate() |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
367 self.loadphaserevs(repo) |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
368 return any( |
48913
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48875
diff
changeset
|
369 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
|
370 ) |
45114
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
371 |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
372 def nonpublicphaseroots(self, repo): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
373 # type: (localrepo.localrepository) -> Set[bytes] |
45114
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
374 """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:
45063
diff
changeset
|
375 |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
376 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:
45063
diff
changeset
|
377 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:
45063
diff
changeset
|
378 """ |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
379 repo = repo.unfiltered() |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
380 cl = repo.changelog |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
381 if len(cl) >= self._loadedrevslen: |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
382 self.invalidate() |
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
383 self.loadphaserevs(repo) |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
384 return set().union( |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
385 *[ |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
386 revs |
48913
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48875
diff
changeset
|
387 for phase, revs in self.phaseroots.items() |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
388 if phase != public |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
389 ] |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
390 ) |
45114
e2d17974a869
phases: provide a test and accessor for non-public phase roots
Joerg Sonnenberger <joerg@bec.de>
parents:
45063
diff
changeset
|
391 |
35330
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
392 def getrevset(self, repo, phases, subset=None): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
393 # type: (localrepo.localrepository, Iterable[int], Optional[Any]) -> Any |
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
394 # TODO: finish typing this |
31016
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
395 """return a smartset for the given phases""" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
396 self.loadphaserevs(repo) # ensure phase's sets are loaded |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
397 phases = set(phases) |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
398 publicphase = public in phases |
44004
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43730
diff
changeset
|
399 |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
400 if publicphase: |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
401 # In this case, phases keeps all the *other* phases. |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
402 phases = set(allphases).difference(phases) |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
403 if not phases: |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
404 return smartset.fullreposet(repo) |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
405 |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
406 # fast path: _phasesets contains the interesting sets, |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
407 # 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
|
408 revsneedscopy = False |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
409 if len(phases) == 1: |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
410 [p] = phases |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
411 revs = self._phasesets[p] |
44065
ab41dad7345e
phases: make phasecache._phasesets immutable
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44064
diff
changeset
|
412 revsneedscopy = True # Don't modify _phasesets |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
413 else: |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
414 # revs has the revisions in all *other* phases. |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
415 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:
44004
diff
changeset
|
416 |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
417 def _addwdir(wdirsubset, wdirrevs): |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
418 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
|
419 if revsneedscopy: |
ab41dad7345e
phases: make phasecache._phasesets immutable
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44064
diff
changeset
|
420 wdirrevs = wdirrevs.copy() |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
421 # 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:
44004
diff
changeset
|
422 # 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:
44004
diff
changeset
|
423 # 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:
44004
diff
changeset
|
424 # included (or filtered out). |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
425 wdirrevs.add(wdirrev) |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
426 return wdirrevs |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
427 |
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
428 if not publicphase: |
31016
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
429 if repo.changelog.filteredrevs: |
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
430 revs = revs - repo.changelog.filteredrevs |
44004
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43730
diff
changeset
|
431 |
35330
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
432 if subset is None: |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
433 return smartset.baseset(revs) |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
434 else: |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
435 revs = _addwdir(subset, revs) |
35330
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
436 return subset & smartset.baseset(revs) |
31016
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
437 else: |
35330
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
438 if subset is None: |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
439 subset = smartset.fullreposet(repo) |
44004
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43730
diff
changeset
|
440 |
44064
8eb3c52337a6
phases: reduce code duplication in phasecache.getrevset
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
44004
diff
changeset
|
441 revs = _addwdir(subset, revs) |
44004
9c1fd975e9ac
phases: make the working directory consistently a draft
Rodrigo Damazio Bovendorp <rdamazio@google.com>
parents:
43730
diff
changeset
|
442 |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
443 if not revs: |
35330
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
444 return subset |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
445 return subset.filter(lambda r: r not in revs) |
31016
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
446 |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
447 def copy(self): |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
448 # Shallow copy meant to ensure isolation in |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
449 # advance/retractboundary(), nothing more. |
23631
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
23361
diff
changeset
|
450 ph = self.__class__(None, None, _load=False) |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
451 ph.phaseroots = self.phaseroots.copy() |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
452 ph.dirty = self.dirty |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
453 ph.opener = self.opener |
35441
98cc121099fe
phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents:
35330
diff
changeset
|
454 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
|
455 ph._phasesets = self._phasesets |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
456 return ph |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
457 |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
458 def replace(self, phcache): |
25613
a13c18c14ade
phase: document the replace method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25611
diff
changeset
|
459 """replace all values in 'self' with content of phcache""" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
460 for a in ( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
461 b'phaseroots', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
462 b'dirty', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
463 b'opener', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
464 b'_loadedrevslen', |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
465 b'_phasesets', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
466 ): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
467 setattr(self, a, getattr(phcache, a)) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
468 |
24599
2a73829ebe17
phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24520
diff
changeset
|
469 def _getphaserevsnative(self, repo): |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
470 repo = repo.unfiltered() |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
471 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
|
472 |
24599
2a73829ebe17
phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24520
diff
changeset
|
473 def _computephaserevspure(self, repo): |
24519
de3acfabaddc
phases: move pure phase computation in a function
Laurent Charignon <lcharignon@fb.com>
parents:
24444
diff
changeset
|
474 repo = repo.unfiltered() |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
475 cl = repo.changelog |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
476 self._phasesets = {phase: set() for phase in allphases} |
39271
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
477 lowerroots = set() |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
478 for phase in reversed(trackedphases): |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
479 roots = pycompat.maplist(cl.rev, self.phaseroots[phase]) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
480 if roots: |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
481 ps = set(cl.descendants(roots)) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
482 for root in roots: |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
483 ps.add(root) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
484 ps.difference_update(lowerroots) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
485 lowerroots.update(ps) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
486 self._phasesets[phase] = ps |
35441
98cc121099fe
phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents:
35330
diff
changeset
|
487 self._loadedrevslen = len(cl) |
24519
de3acfabaddc
phases: move pure phase computation in a function
Laurent Charignon <lcharignon@fb.com>
parents:
24444
diff
changeset
|
488 |
25611
d89045a66e01
phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25594
diff
changeset
|
489 def loadphaserevs(self, repo): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
490 # type: (localrepo.localrepository) -> None |
25611
d89045a66e01
phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25594
diff
changeset
|
491 """ensure phase information is loaded in the object""" |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
492 if self._phasesets is None: |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
493 try: |
31152
b7cef987356d
phases: remove experimental.nativephaseskillswitch
Jun Wu <quark@fb.com>
parents:
31053
diff
changeset
|
494 res = self._getphaserevsnative(repo) |
35441
98cc121099fe
phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents:
35330
diff
changeset
|
495 self._loadedrevslen, self._phasesets = res |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
496 except AttributeError: |
24599
2a73829ebe17
phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24520
diff
changeset
|
497 self._computephaserevspure(repo) |
22894
c40be72dc177
phases: move root phase assignment to it's own function
Durham Goode <durham@fb.com>
parents:
22893
diff
changeset
|
498 |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
499 def invalidate(self): |
35442
56745e58df07
phases: initialize number of loaded revisions to 0
Yuya Nishihara <yuya@tcha.org>
parents:
35441
diff
changeset
|
500 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
|
501 self._phasesets = None |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
502 |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
503 def phase(self, repo, rev): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
504 # type: (localrepo.localrepository, int) -> int |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
505 # 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
|
506 # if necessary. The repository instance is not stored in |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
507 # phasecache to avoid reference cycles. The changelog instance |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
508 # is not stored because it is a filecache() property and can |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
509 # be replaced without us being notified. |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
510 if rev == nullrev: |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
511 return public |
19984
7d5e7799a29f
rebase: fix rebase aborts when 'tip-1' is public (issue4082)
Durham Goode <durham@fb.com>
parents:
19951
diff
changeset
|
512 if rev < nullrev: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
513 raise ValueError(_(b'cannot lookup negative revision')) |
35441
98cc121099fe
phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents:
35330
diff
changeset
|
514 if rev >= self._loadedrevslen: |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
515 self.invalidate() |
25611
d89045a66e01
phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25594
diff
changeset
|
516 self.loadphaserevs(repo) |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
517 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
|
518 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
|
519 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
|
520 return public |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
521 |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
522 def write(self): |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
523 if not self.dirty: |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
524 return |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
525 f = self.opener(b'phaseroots', b'w', atomictemp=True, checkambig=True) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
526 try: |
22079
5dcc58649b1a
phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22070
diff
changeset
|
527 self._write(f) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
528 finally: |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
529 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
|
530 |
5dcc58649b1a
phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22070
diff
changeset
|
531 def _write(self, fp): |
48913
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48875
diff
changeset
|
532 for phase, roots in self.phaseroots.items(): |
36452
ab81e5a8fba5
phases: write phaseroots deterministically
Gregory Szorc <gregory.szorc@gmail.com>
parents:
35442
diff
changeset
|
533 for h in sorted(roots): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
534 fp.write(b'%i %s\n' % (phase, hex(h))) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
535 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
|
536 |
22080
37f46575d9c2
phase: attach phase to the transaction instead of the lock
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22079
diff
changeset
|
537 def _updateroots(self, phase, newroots, tr): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
538 self.phaseroots[phase] = newroots |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
539 self.invalidate() |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
540 self.dirty = True |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
541 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
542 tr.addfilegenerator(b'phase', (b'phaseroots',), self._write) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
543 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
|
544 |
45790
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45789
diff
changeset
|
545 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
|
546 repo = repo.unfiltered() |
45790
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45789
diff
changeset
|
547 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
|
548 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
|
549 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
|
550 phase = self.phase |
45790
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45789
diff
changeset
|
551 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
|
552 revphase = phase(repo, rev) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
553 _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
|
554 repo.invalidatevolatilesets() |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
555 |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
556 def advanceboundary( |
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
557 self, repo, tr, targetphase, nodes, revs=None, dryrun=None |
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
558 ): |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
559 """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
|
560 |
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
561 Nodes with a phase lower than 'targetphase' are not affected. |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
562 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
563 If dryrun is True, no actions will be performed |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
564 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
565 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
|
566 """ |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
567 # 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
|
568 # phaseroots values, replace them. |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
569 if revs is None: |
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
570 revs = [] |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
571 if tr is None: |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
572 phasetracking = None |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
573 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
574 phasetracking = tr.changes.get(b'phases') |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
575 |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
576 repo = repo.unfiltered() |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
577 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
|
578 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
579 changes = set() # set of revisions to be changed |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
580 delroots = [] # set of root deleted by this path |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
581 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
|
582 # filter nodes that are not in a compatible phase already |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
583 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:
45550
diff
changeset
|
584 if not revs: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
585 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
|
586 |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
587 olds = self.phaseroots[phase] |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
588 |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
589 affected = repo.revs(b'%ln::%ld', olds, revs) |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
590 changes.update(affected) |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
591 if dryrun: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
592 continue |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
593 for r in affected: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
594 _trackphasechange( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
595 phasetracking, r, self.phase(repo, r), targetphase |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
596 ) |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
597 |
44452
9d2b2df2c2ba
cleanup: run pyupgrade on our source tree to clean up varying things
Augie Fackler <augie@google.com>
parents:
44065
diff
changeset
|
598 roots = { |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
599 ctx.node() |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
600 for ctx in repo.set(b'roots((%ln::) - %ld)', olds, affected) |
44452
9d2b2df2c2ba
cleanup: run pyupgrade on our source tree to clean up varying things
Augie Fackler <augie@google.com>
parents:
44065
diff
changeset
|
601 } |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
602 if olds != roots: |
22080
37f46575d9c2
phase: attach phase to the transaction instead of the lock
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22079
diff
changeset
|
603 self._updateroots(phase, roots, tr) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
604 # 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
|
605 delroots.extend(olds - roots) |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
606 if not dryrun: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
607 # declare deleted root in the target phase |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
608 if targetphase != 0: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
609 self._retractboundary(repo, tr, targetphase, delroots) |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
610 repo.invalidatevolatilesets() |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
611 return changes |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
612 |
22070
c1ca47204590
phase: add a transaction argument to retractboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22069
diff
changeset
|
613 def retractboundary(self, repo, tr, targetphase, nodes): |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
614 oldroots = { |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
615 phase: revs |
48913
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48875
diff
changeset
|
616 for phase, revs in self.phaseroots.items() |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
617 if phase <= targetphase |
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
618 } |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
619 if tr is None: |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
620 phasetracking = None |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
621 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
622 phasetracking = tr.changes.get(b'phases') |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
623 repo = repo.unfiltered() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
624 if ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
625 self._retractboundary(repo, tr, targetphase, nodes) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
626 and phasetracking is not None |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
627 ): |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
628 |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
629 # find the affected revisions |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
630 new = self.phaseroots[targetphase] |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
631 old = oldroots[targetphase] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
632 affected = set(repo.revs(b'(%ln::) - (%ln::)', new, old)) |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
633 |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
634 # find the phase of the affected revision |
49284
d44e3c45f0e4
py3: replace `pycompat.xrange` by `range`
Manuel Jacob <me@manueljacob.de>
parents:
48946
diff
changeset
|
635 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
|
636 if phase: |
45131
61e7464477ac
phases: sparsify phaseroots and phasesets
Joerg Sonnenberger <joerg@bec.de>
parents:
45117
diff
changeset
|
637 roots = oldroots.get(phase, []) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
638 revs = set(repo.revs(b'%ln::%ld', roots, affected)) |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
639 affected -= revs |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
640 else: # public phase |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
641 revs = affected |
44548
fdc802f29b2c
transactions: convert changes['phases'] to list of ranges
Joerg Sonnenberger <joerg@bec.de>
parents:
44452
diff
changeset
|
642 for r in sorted(revs): |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
643 _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
|
644 repo.invalidatevolatilesets() |
7b25a56366cf
phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33451
diff
changeset
|
645 |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
646 def _retractboundary(self, repo, tr, targetphase, nodes, revs=None): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
647 # 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
|
648 # phaseroots values, replace them. |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
649 if revs is None: |
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
650 revs = [] |
49450
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49306
diff
changeset
|
651 if ( |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49306
diff
changeset
|
652 targetphase == internal |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49306
diff
changeset
|
653 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:
49306
diff
changeset
|
654 or targetphase == archived |
b57c95a0f5f9
phase: introduce a dedicated function to check for the archived phase
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
49306
diff
changeset
|
655 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:
49306
diff
changeset
|
656 ): |
40417
49c7b701fdc2
phase: add an archived phase
Boris Feld <boris.feld@octobus.net>
parents:
39299
diff
changeset
|
657 name = phasenames[targetphase] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
658 msg = b'this repository does not support the %s phase' % name |
39299
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
659 raise error.ProgrammingError(msg) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
660 |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
661 repo = repo.unfiltered() |
44988
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
662 torev = repo.changelog.rev |
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
663 tonode = repo.changelog.node |
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
664 currentroots = {torev(node) for node in self.phaseroots[targetphase]} |
33457
61714c282106
phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents:
33453
diff
changeset
|
665 finalroots = oldroots = set(currentroots) |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
666 newroots = [torev(node) for node in nodes] + [r for r in revs] |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
667 newroots = [ |
44988
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
668 rev for rev in newroots if self.phase(repo, rev) < targetphase |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
669 ] |
44988
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
670 |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
671 if newroots: |
44988
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
672 if nullrev in newroots: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
673 raise error.Abort(_(b'cannot change null revision phase')) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
674 currentroots.update(newroots) |
26909
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
675 |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
676 # Only compute new roots for revs above the roots that are being |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
677 # retracted. |
44988
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
678 minnewroot = min(newroots) |
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
679 aboveroots = [rev for rev in currentroots if rev >= minnewroot] |
44993
98f97026fa05
phases: remove useless lookup of repo[rev].rev() in _retractboundary
Yuya Nishihara <yuya@tcha.org>
parents:
44988
diff
changeset
|
680 updatedroots = repo.revs(b'roots(%ld::)', aboveroots) |
26909
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
681 |
44988
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
682 finalroots = {rev for rev in currentroots if rev < minnewroot} |
44993
98f97026fa05
phases: remove useless lookup of repo[rev].rev() in _retractboundary
Yuya Nishihara <yuya@tcha.org>
parents:
44988
diff
changeset
|
683 finalroots.update(updatedroots) |
33457
61714c282106
phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents:
33453
diff
changeset
|
684 if finalroots != oldroots: |
44988
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
685 self._updateroots( |
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
686 targetphase, {tonode(rev) for rev in finalroots}, tr |
fa151f7af275
phases: improve performance of _retractboundary
Joerg Sonnenberger <joerg@bec.de>
parents:
44548
diff
changeset
|
687 ) |
33457
61714c282106
phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents:
33453
diff
changeset
|
688 return True |
61714c282106
phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents:
33453
diff
changeset
|
689 return False |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
690 |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
691 def filterunknown(self, repo): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
692 # type: (localrepo.localrepository) -> None |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
693 """remove unknown nodes from the phase boundary |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
694 |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
695 Nothing is lost as unknown nodes only hold data for their descendants. |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
696 """ |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
697 filtered = False |
43539
44f54b8f9f10
index: use `index.has_node` in `phases.filterunknown`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43538
diff
changeset
|
698 has_node = repo.changelog.index.has_node # to filter unknown nodes |
48913
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48875
diff
changeset
|
699 for phase, nodes in self.phaseroots.items(): |
43539
44f54b8f9f10
index: use `index.has_node` in `phases.filterunknown`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43538
diff
changeset
|
700 missing = sorted(node for node in nodes if not has_node(node)) |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
701 if missing: |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
702 for mnode in missing: |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
703 repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
704 b'removing unknown node %s from %i-phase boundary\n' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
705 % (short(mnode), phase) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
706 ) |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
707 nodes.symmetric_difference_update(missing) |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
708 filtered = True |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
709 if filtered: |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
710 self.dirty = True |
18983
31bcc5112191
destroyed: invalidate phraserevs cache in all case (issue3858)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18220
diff
changeset
|
711 # filterunknown is called by repo.destroyed, we may have no changes in |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
712 # root but _phasesets contents is certainly invalid (or at least we |
19951
d51c4d85ec23
spelling: random spell checker fixes
Mads Kiilerich <madski@unity3d.com>
parents:
18983
diff
changeset
|
713 # have not proper way to check that). related to issue 3858. |
18983
31bcc5112191
destroyed: invalidate phraserevs cache in all case (issue3858)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18220
diff
changeset
|
714 # |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
715 # The other caller is __init__ that have no _phasesets initialized |
18983
31bcc5112191
destroyed: invalidate phraserevs cache in all case (issue3858)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18220
diff
changeset
|
716 # anyway. If this change we should consider adding a dedicated |
19951
d51c4d85ec23
spelling: random spell checker fixes
Mads Kiilerich <madski@unity3d.com>
parents:
18983
diff
changeset
|
717 # "destroyed" function to phasecache or a proper cache key mechanism |
18983
31bcc5112191
destroyed: invalidate phraserevs cache in all case (issue3858)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
18220
diff
changeset
|
718 # (see branchmap one) |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
719 self.invalidate() |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
720 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
721 |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
722 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
|
723 """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
|
724 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
725 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
|
726 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
|
727 |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
728 Simplify boundary to contains phase roots only. |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
729 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
730 If dryrun is True, no actions will be performed |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
731 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
732 Returns a set of revs whose phase is changed or should be changed |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
733 """ |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
734 if revs is None: |
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
735 revs = [] |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
736 phcache = repo._phasecache.copy() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
737 changes = phcache.advanceboundary( |
45789
09735cde6275
phases: allow registration and boundary advancement with revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45550
diff
changeset
|
738 repo, tr, targetphase, nodes, revs=revs, dryrun=dryrun |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
739 ) |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
740 if not dryrun: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
741 repo._phasecache.replace(phcache) |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
742 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
|
743 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
744 |
22070
c1ca47204590
phase: add a transaction argument to retractboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22069
diff
changeset
|
745 def retractboundary(repo, tr, targetphase, nodes): |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
746 """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
|
747 necessary. |
15482
a667c89e49b3
phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15481
diff
changeset
|
748 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
749 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
|
750 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
|
751 |
a667c89e49b3
phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15481
diff
changeset
|
752 Simplify boundary to contains phase roots only.""" |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
753 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
|
754 phcache.retractboundary(repo, tr, targetphase, nodes) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
755 repo._phasecache.replace(phcache) |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
756 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
757 |
45790
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45789
diff
changeset
|
758 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
|
759 """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
|
760 |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
761 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
|
762 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
|
763 """ |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
764 phcache = repo._phasecache.copy() |
45790
5d65e04b6a80
phases: convert registernew users to use revision sets
Joerg Sonnenberger <joerg@bec.de>
parents:
45789
diff
changeset
|
765 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
|
766 repo._phasecache.replace(phcache) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
767 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
768 |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
769 def listphases(repo): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
770 # type: (localrepo.localrepository) -> Dict[bytes, bytes] |
16724
00535da82faf
phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents:
16659
diff
changeset
|
771 """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:
31342
diff
changeset
|
772 # Use ordered dictionary so behavior is deterministic. |
511a62669f1b
phases: emit phases to pushkey protocol in deterministic order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31342
diff
changeset
|
773 keys = util.sortdict() |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
774 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
|
775 cl = repo.unfiltered().changelog |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
776 for root in repo._phasecache.phaseroots[draft]: |
34816
e2c42f751b06
phase: filter out non-draft item in "draft root"
Boris Feld <boris.feld@octobus.net>
parents:
34710
diff
changeset
|
777 if repo._phasecache.phase(repo, cl.rev(root)) <= draft: |
e2c42f751b06
phase: filter out non-draft item in "draft root"
Boris Feld <boris.feld@octobus.net>
parents:
34710
diff
changeset
|
778 keys[hex(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
|
779 |
25624
f0745da75056
publishing: use new helper method
Matt Mackall <mpm@selenic.com>
parents:
25614
diff
changeset
|
780 if repo.publishing(): |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
781 # 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
|
782 # 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
|
783 # 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
|
784 # push phase boundary |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
785 # |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
786 # 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
|
787 # 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
|
788 # 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
|
789 # |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
790 # 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
|
791 # 2) repo B make changeset X public |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
792 # 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
|
793 # X as now public should |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
794 # |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
795 # 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
|
796 # client phase data. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
797 keys[b'publishing'] = b'True' |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
798 return keys |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
799 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
800 |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
801 def pushphase(repo, nhex, oldphasestr, newphasestr): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
802 # type: (localrepo.localrepository, bytes, bytes, bytes) -> bool |
17535 | 803 """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
|
804 repo = repo.unfiltered() |
27861
3315a9c2019c
with: use context manager for lock in pushphase
Bryan O'Sullivan <bryano@fb.com>
parents:
26909
diff
changeset
|
805 with repo.lock(): |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
806 currentphase = repo[nhex].phase() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
807 newphase = abs(int(newphasestr)) # let's avoid negative index surprise |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
808 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
|
809 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
|
810 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
|
811 advanceboundary(repo, tr, newphase, [bin(nhex)]) |
32822
e65ff29dbeb0
pushkey: use False/True for return values from push functions
Martin von Zweigbergk <martinvonz@google.com>
parents:
32000
diff
changeset
|
812 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
|
813 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
|
814 # raced, but got correct result |
32822
e65ff29dbeb0
pushkey: use False/True for return values from push functions
Martin von Zweigbergk <martinvonz@google.com>
parents:
32000
diff
changeset
|
815 return True |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
816 else: |
32822
e65ff29dbeb0
pushkey: use False/True for return values from push functions
Martin von Zweigbergk <martinvonz@google.com>
parents:
32000
diff
changeset
|
817 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
|
818 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
819 |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
820 def subsetphaseheads(repo, subset): |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
821 """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:
32822
diff
changeset
|
822 |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
823 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:
32822
diff
changeset
|
824 head nodes. |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
825 """ |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
826 cl = repo.changelog |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
827 |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
828 headsbyphase = {i: [] for i in allphases} |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
829 # No need to keep track of secret phase; any heads in the subset that |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
830 # are not mentioned are implicitly secret. |
39272
160bd45cc6af
phase: explicitly exclude secret phase and above
Boris Feld <boris.feld@octobus.net>
parents:
39271
diff
changeset
|
831 for phase in allphases[:secret]: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
832 revset = b"heads(%%ln & %s())" % phasenames[phase] |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
833 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:
32822
diff
changeset
|
834 return headsbyphase |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
835 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
836 |
34321
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34320
diff
changeset
|
837 def updatephases(repo, trgetter, headsbyphase): |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
838 """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
|
839 # Now advance phase boundaries of all phases |
34321
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34320
diff
changeset
|
840 # |
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34320
diff
changeset
|
841 # 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:
34320
diff
changeset
|
842 # 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:
34320
diff
changeset
|
843 |
45116
361a7444bc41
phases: updatephases should not skip internal phase
Joerg Sonnenberger <joerg@bec.de>
parents:
45114
diff
changeset
|
844 for phase in allphases: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
845 revset = b'%ln - _phase(%s)' |
39293
278eb4541758
phases: simplify revset in updatephases
Boris Feld <boris.feld@octobus.net>
parents:
39275
diff
changeset
|
846 heads = [c.node() for c in repo.set(revset, headsbyphase[phase], phase)] |
34321
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34320
diff
changeset
|
847 if heads: |
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34320
diff
changeset
|
848 advanceboundary(repo, trgetter(), phase, heads) |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
849 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
850 |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
851 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
|
852 """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
|
853 |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
854 * 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
|
855 * 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
|
856 |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
857 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
|
858 """ |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
859 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
|
860 # 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
|
861 draftroots = [] |
43538
9970412d2ce3
index: use `index.has_node` in `analyzeremotephases`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43106
diff
changeset
|
862 has_node = repo.changelog.index.has_node # to filter unknown nodes |
48913
f254fc73d956
global: bulk replace simple pycompat.iteritems(x) with x.items()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48875
diff
changeset
|
863 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
|
864 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
|
865 continue |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
866 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
|
867 phase = int(phase) |
28174
f16b84b1e40e
phases: use constants for phase values
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27874
diff
changeset
|
868 if phase == public: |
47012
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46644
diff
changeset
|
869 if node != repo.nullid: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
870 repo.ui.warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
871 _( |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
872 b'ignoring inconsistent public root' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
873 b' from remote: %s\n' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
874 ) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
875 % nhex |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
876 ) |
28174
f16b84b1e40e
phases: use constants for phase values
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27874
diff
changeset
|
877 elif phase == draft: |
43538
9970412d2ce3
index: use `index.has_node` in `analyzeremotephases`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43106
diff
changeset
|
878 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
|
879 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
|
880 else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
881 repo.ui.warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
882 _(b'ignoring unexpected root from remote: %i %s\n') |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
883 % (phase, nhex) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
884 ) |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
885 # compute heads |
15954
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
886 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
|
887 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
|
888 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
889 |
48946
642e31cb55f0
py3: use class X: instead of class X(object):
Gregory Szorc <gregory.szorc@gmail.com>
parents:
48913
diff
changeset
|
890 class remotephasessummary: |
34819
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
891 """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
|
892 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
893 :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
|
894 :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
|
895 :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
|
896 :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
|
897 """ |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
898 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
899 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
|
900 unfi = repo.unfiltered() |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
901 self._allremoteroots = remoteroots |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
902 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
903 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
|
904 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
905 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
|
906 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
|
907 # 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
|
908 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
|
909 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
|
910 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
911 |
15954
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
912 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
|
913 """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
|
914 |
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
915 * `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
|
916 * `roots`: define the second we subtract from the first""" |
39146
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
917 # prevent an import cycle |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
918 # phases > dagop > patch > copies > scmutil > obsolete > obsutil > phases |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
919 from . import dagop |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
920 |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
921 repo = repo.unfiltered() |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
922 cl = repo.changelog |
43556
505a2bc53759
index: use `index.get_rev` in `phases.newheads`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43539
diff
changeset
|
923 rev = cl.index.get_rev |
39146
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
924 if not roots: |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
925 return heads |
47012
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46644
diff
changeset
|
926 if not heads or heads == [repo.nullid]: |
39146
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
927 return [] |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
928 # The logic operated on revisions, convert arguments early for convenience |
47012
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46644
diff
changeset
|
929 new_heads = {rev(n) for n in heads if n != repo.nullid} |
39146
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
930 roots = [rev(n) for n in roots] |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
931 # 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
|
932 affected_zone = repo.revs(b"(%ld::%ld)", roots, new_heads) |
39146
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
933 # heads in the area are no longer heads |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
934 new_heads.difference_update(affected_zone) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
935 # revisions in the area have children outside of it, |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
936 # They might be new heads |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
937 candidates = repo.revs( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
938 b"parents(%ld + (%ld and merge())) and not null", roots, affected_zone |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
939 ) |
39146
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
940 candidates -= affected_zone |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
941 if new_heads or candidates: |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
942 # remove candidate that are ancestors of other heads |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
943 new_heads.update(candidates) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
944 prunestart = repo.revs(b"parents(%ld) and not null", new_heads) |
39146
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
945 pruned = dagop.reachableroots(repo, candidates, prunestart) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
946 new_heads.difference_update(pruned) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
947 |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
948 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
|
949 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
950 |
16030
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
951 def newcommitphase(ui): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
952 # type: (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
|
953 """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
|
954 |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
955 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
|
956 |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
957 """ |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
958 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
|
959 try: |
45117
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
960 return phasenumber2[v] |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
961 except KeyError: |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
962 raise error.ConfigError( |
b1e51ef4e536
phases: sparsify phase lists
Joerg Sonnenberger <joerg@bec.de>
parents:
45116
diff
changeset
|
963 _(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
|
964 ) |
16030
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
965 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
966 |
17671
fdd0fc046cf1
clfilter: introduce a `hassecret` function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17537
diff
changeset
|
967 def hassecret(repo): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
968 # type: (localrepo.localrepository) -> bool |
17671
fdd0fc046cf1
clfilter: introduce a `hassecret` function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17537
diff
changeset
|
969 """utility function that check if a repo have any secret changeset.""" |
45063
6232d732658c
phases: replace magic number by constant
Joerg Sonnenberger <joerg@bec.de>
parents:
44993
diff
changeset
|
970 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
|
971 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
40580
diff
changeset
|
972 |
34710
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
973 def preparehookargs(node, old, new): |
46644
77e129be10de
typing: add some type annotations to mercurial/phases.py
Matt Harbison <matt_harbison@yahoo.com>
parents:
45790
diff
changeset
|
974 # type: (bytes, Optional[int], Optional[int]) -> Dict[bytes, bytes] |
34710
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
975 if old is None: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
976 old = b'' |
34710
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
977 else: |
34876
eb1b964b354b
phases: pass phase names to hooks instead of internal values
Kevin Bullock <kbullock+mercurial@ringworld.org>
parents:
34819
diff
changeset
|
978 old = phasenames[old] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
979 return {b'node': node, b'oldphase': old, b'phase': phasenames[new]} |