Mercurial > hg
annotate mercurial/phases.py @ 39634:9dffa99f9158
wireprotov2: add bookmarks to "changesetdata" command
Like we did for phases, we want to emit bookmarks data attached
to each changeset.
The approach here is very similar to phases: we emit bookmarks
data inline with requested revision data. But we emit
records for nodes that weren't requested as well so consumers have
access to the full set of defined bookmarks.
Differential Revision: https://phab.mercurial-scm.org/D4485
author | Gregory Szorc <gregory.szorc@gmail.com> |
---|---|
date | Thu, 23 Aug 2018 18:14:19 -0700 |
parents | 7775c1fb8fa0 |
children | 49c7b701fdc2 |
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 from __future__ import absolute_import |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
104 |
15419
ccb7de21625a
phases: handle errors other than ENOENT appropriately
Matt Mackall <mpm@selenic.com>
parents:
15418
diff
changeset
|
105 import errno |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
106 import struct |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
107 |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
108 from .i18n import _ |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
109 from .node import ( |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
110 bin, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
111 hex, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
112 nullid, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
113 nullrev, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
114 short, |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
115 ) |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
116 from . import ( |
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
117 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
|
118 pycompat, |
31016
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
119 smartset, |
31053
6afd8a87a657
phases: check HG_PENDING strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31016
diff
changeset
|
120 txnutil, |
32000
511a62669f1b
phases: emit phases to pushkey protocol in deterministic order
Gregory Szorc <gregory.szorc@gmail.com>
parents:
31342
diff
changeset
|
121 util, |
25966
f14cea32e1d4
phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25660
diff
changeset
|
122 ) |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
123 |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
124 _fphasesentry = struct.Struct('>i20s') |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
125 |
39297
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
126 INTERNAL_FLAG = 64 # Phases for mercurial internal usage only |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
127 HIDEABLE_FLAG = 32 # Phases that are hideable |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
128 |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
129 # record phase index |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
130 public, draft, secret = range(3) |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
131 internal = INTERNAL_FLAG | HIDEABLE_FLAG |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
132 allphases = range(internal + 1) |
15417
5261140d9322
phases: Minimal first add.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
diff
changeset
|
133 trackedphases = allphases[1:] |
39297
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
134 # record phase names |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
135 phasenames = [None] * len(allphases) |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
136 phasenames[:3] = ['public', 'draft', 'secret'] |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
137 phasenames[internal] = 'internal' |
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
138 # record phase property |
38157
02f992ac26e9
phases: define an official tuple of mutable phases
Boris Feld <boris.feld@octobus.net>
parents:
36624
diff
changeset
|
139 mutablephases = tuple(allphases[1:]) |
38158
4e790f0966fc
phases: define an official tuple of phases we do not share
Boris Feld <boris.feld@octobus.net>
parents:
38157
diff
changeset
|
140 remotehiddenphases = tuple(allphases[2:]) |
39297
06c976acc581
phases: add an internal phases
Boris Feld <boris.feld@octobus.net>
parents:
39293
diff
changeset
|
141 localhiddenphases = tuple(p for p in allphases if p & HIDEABLE_FLAG) |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
142 |
39299
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
143 def supportinternal(repo): |
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
144 """True if the internal phase can be used on a repository""" |
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
145 return 'internal-phase' in repo.requirements |
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
146 |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
147 def _readroots(repo, phasedefaults=None): |
16625
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
148 """Read phase roots from disk |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
149 |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
150 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
|
151 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
|
152 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
|
153 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
|
154 |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
155 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
|
156 what is being stored. |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
157 """ |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
158 repo = repo.unfiltered() |
16625
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
159 dirty = False |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
160 roots = [set() for i in allphases] |
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
161 try: |
31053
6afd8a87a657
phases: check HG_PENDING strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31016
diff
changeset
|
162 f, pending = txnutil.trypending(repo.root, repo.svfs, 'phaseroots') |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
163 try: |
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
164 for line in f: |
16588
72319bfd7966
phases: line.strip().split() == line.split()
Martin Geisler <mg@aragost.com>
parents:
16535
diff
changeset
|
165 phase, nh = line.split() |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
166 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
|
167 finally: |
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
168 f.close() |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25624
diff
changeset
|
169 except IOError as inst: |
15419
ccb7de21625a
phases: handle errors other than ENOENT appropriately
Matt Mackall <mpm@selenic.com>
parents:
15418
diff
changeset
|
170 if inst.errno != errno.ENOENT: |
ccb7de21625a
phases: handle errors other than ENOENT appropriately
Matt Mackall <mpm@selenic.com>
parents:
15418
diff
changeset
|
171 raise |
16625
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
172 if phasedefaults: |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
173 for f in phasedefaults: |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
174 roots = f(repo, roots) |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
175 dirty = True |
df9df747070d
phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents:
16624
diff
changeset
|
176 return roots, dirty |
15418
cf729af26963
phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15417
diff
changeset
|
177 |
34319
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
178 def binaryencode(phasemapping): |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
179 """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
|
180 |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
181 Since phases are integer the mapping is actually a python list: |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
182 [[PUBLIC_HEADS], [DRAFTS_HEADS], [SECRET_HEADS]] |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
183 """ |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
184 binarydata = [] |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
185 for phase, nodes in enumerate(phasemapping): |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
186 for head in nodes: |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
187 binarydata.append(_fphasesentry.pack(phase, head)) |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
188 return ''.join(binarydata) |
5779d096a696
phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents:
33460
diff
changeset
|
189 |
34320
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
190 def binarydecode(stream): |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
191 """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
|
192 |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
193 Since phases are integer the mapping is actually a python list.""" |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
194 headsbyphase = [[] for i in allphases] |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
195 entrysize = _fphasesentry.size |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
196 while True: |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
197 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
|
198 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
|
199 if entry: |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
200 raise error.Abort(_('bad phase-heads stream')) |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
201 break |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
202 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
|
203 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
|
204 return headsbyphase |
12c42bcd4133
phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents:
34319
diff
changeset
|
205 |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
206 def _trackphasechange(data, rev, old, new): |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
207 """add a phase move the <data> dictionnary |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
208 |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
209 If data is None, nothing happens. |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
210 """ |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
211 if data is None: |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
212 return |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
213 existing = data.get(rev) |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
214 if existing is not None: |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
215 old = existing[0] |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
216 data[rev] = (old, new) |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
217 |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
218 class phasecache(object): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
219 def __init__(self, repo, phasedefaults, _load=True): |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
220 if _load: |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
221 # Cheap trick to allow shallow-copy without copy module |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
222 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
|
223 self._loadedrevslen = 0 |
25190
22438cfd11b5
phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24599
diff
changeset
|
224 self._phasesets = None |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
225 self.filterunknown(repo) |
23878
37a92908a382
localrepo: remove all external users of localrepo.sopener
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
23631
diff
changeset
|
226 self.opener = repo.svfs |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
227 |
35330
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
228 def getrevset(self, repo, phases, subset=None): |
31016
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
229 """return a smartset for the given phases""" |
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
230 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
|
231 phases = set(phases) |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
232 if public not in phases: |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
233 # fast path: _phasesets contains the interesting sets, |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
234 # might only need a union and post-filtering. |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
235 if len(phases) == 1: |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
236 [p] = phases |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
237 revs = self._phasesets[p] |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
238 else: |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
239 revs = set.union(*[self._phasesets[p] for p in phases]) |
31016
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
240 if repo.changelog.filteredrevs: |
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
241 revs = revs - repo.changelog.filteredrevs |
35330
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
242 if subset is None: |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
243 return smartset.baseset(revs) |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
244 else: |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
245 return subset & smartset.baseset(revs) |
31016
bf81d3b7b2ba
phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents:
30634
diff
changeset
|
246 else: |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
247 phases = set(allphases).difference(phases) |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
248 if not phases: |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
249 return smartset.fullreposet(repo) |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
250 if len(phases) == 1: |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
251 [p] = phases |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
252 revs = self._phasesets[p] |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
253 else: |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
254 revs = set.union(*[self._phasesets[p] for p in phases]) |
35330
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
255 if subset is None: |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
256 subset = smartset.fullreposet(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
|
257 if not revs: |
35330
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
258 return subset |
0c1aff6d73a7
revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents:
35309
diff
changeset
|
259 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
|
260 |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
261 def copy(self): |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
262 # Shallow copy meant to ensure isolation in |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
263 # advance/retractboundary(), nothing more. |
23631
b8260abfeb7d
bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents:
23361
diff
changeset
|
264 ph = self.__class__(None, None, _load=False) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
265 ph.phaseroots = self.phaseroots[:] |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
266 ph.dirty = self.dirty |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
267 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
|
268 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
|
269 ph._phasesets = self._phasesets |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
270 return ph |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
271 |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
272 def replace(self, phcache): |
25613
a13c18c14ade
phase: document the replace method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25611
diff
changeset
|
273 """replace all values in 'self' with content of phcache""" |
35441
98cc121099fe
phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents:
35330
diff
changeset
|
274 for a in ('phaseroots', 'dirty', 'opener', '_loadedrevslen', |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
275 '_phasesets'): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
276 setattr(self, a, getattr(phcache, a)) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
277 |
24599
2a73829ebe17
phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24520
diff
changeset
|
278 def _getphaserevsnative(self, repo): |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
279 repo = repo.unfiltered() |
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
280 nativeroots = [] |
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
281 for phase in trackedphases: |
36624
3118766266ae
py3: do not pass a list of iterators to computephasesmapsets()
Yuya Nishihara <yuya@tcha.org>
parents:
36452
diff
changeset
|
282 nativeroots.append(pycompat.maplist(repo.changelog.rev, |
3118766266ae
py3: do not pass a list of iterators to computephasesmapsets()
Yuya Nishihara <yuya@tcha.org>
parents:
36452
diff
changeset
|
283 self.phaseroots[phase])) |
25527
262e6ad93885
phases: really fix native phase computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25190
diff
changeset
|
284 return repo.changelog.computephases(nativeroots) |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
285 |
24599
2a73829ebe17
phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24520
diff
changeset
|
286 def _computephaserevspure(self, repo): |
24519
de3acfabaddc
phases: move pure phase computation in a function
Laurent Charignon <lcharignon@fb.com>
parents:
24444
diff
changeset
|
287 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
|
288 cl = repo.changelog |
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
289 self._phasesets = [set() for phase in allphases] |
39271
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
290 lowerroots = set() |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
291 for phase in reversed(trackedphases): |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
292 roots = pycompat.maplist(cl.rev, self.phaseroots[phase]) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
293 if roots: |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
294 ps = set(cl.descendants(roots)) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
295 for root in roots: |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
296 ps.add(root) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
297 ps.difference_update(lowerroots) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
298 lowerroots.update(ps) |
fd7376fa60e7
phase: use `trackedphases` in `_getphaserevsnative`
Boris Feld <boris.feld@octobus.net>
parents:
39262
diff
changeset
|
299 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
|
300 self._loadedrevslen = len(cl) |
24519
de3acfabaddc
phases: move pure phase computation in a function
Laurent Charignon <lcharignon@fb.com>
parents:
24444
diff
changeset
|
301 |
25611
d89045a66e01
phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25594
diff
changeset
|
302 def loadphaserevs(self, repo): |
d89045a66e01
phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25594
diff
changeset
|
303 """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
|
304 if self._phasesets is None: |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
305 try: |
31152
b7cef987356d
phases: remove experimental.nativephaseskillswitch
Jun Wu <quark@fb.com>
parents:
31053
diff
changeset
|
306 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
|
307 self._loadedrevslen, self._phasesets = res |
24444
27e3ba73fbb1
phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
23878
diff
changeset
|
308 except AttributeError: |
24599
2a73829ebe17
phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents:
24520
diff
changeset
|
309 self._computephaserevspure(repo) |
22894
c40be72dc177
phases: move root phase assignment to it's own function
Durham Goode <durham@fb.com>
parents:
22893
diff
changeset
|
310 |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
311 def invalidate(self): |
35442
56745e58df07
phases: initialize number of loaded revisions to 0
Yuya Nishihara <yuya@tcha.org>
parents:
35441
diff
changeset
|
312 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
|
313 self._phasesets = None |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
314 |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
315 def phase(self, repo, rev): |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
316 # 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
|
317 # if necessary. The repository instance is not stored in |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
318 # phasecache to avoid reference cycles. The changelog instance |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
319 # is not stored because it is a filecache() property and can |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
320 # be replaced without us being notified. |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
321 if rev == nullrev: |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
322 return public |
19984
7d5e7799a29f
rebase: fix rebase aborts when 'tip-1' is public (issue4082)
Durham Goode <durham@fb.com>
parents:
19951
diff
changeset
|
323 if rev < nullrev: |
7d5e7799a29f
rebase: fix rebase aborts when 'tip-1' is public (issue4082)
Durham Goode <durham@fb.com>
parents:
19951
diff
changeset
|
324 raise ValueError(_('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
|
325 if rev >= self._loadedrevslen: |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
326 self.invalidate() |
25611
d89045a66e01
phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25594
diff
changeset
|
327 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
|
328 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
|
329 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
|
330 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
|
331 return public |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
332 |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
333 def write(self): |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
334 if not self.dirty: |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
335 return |
29303
3a2357c31d2a
phases: make writing phaseroots file out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28174
diff
changeset
|
336 f = self.opener('phaseroots', 'w', atomictemp=True, checkambig=True) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
337 try: |
22079
5dcc58649b1a
phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22070
diff
changeset
|
338 self._write(f) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
339 finally: |
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
340 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
|
341 |
5dcc58649b1a
phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22070
diff
changeset
|
342 def _write(self, fp): |
5dcc58649b1a
phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22070
diff
changeset
|
343 for phase, roots in enumerate(self.phaseroots): |
36452
ab81e5a8fba5
phases: write phaseroots deterministically
Gregory Szorc <gregory.szorc@gmail.com>
parents:
35442
diff
changeset
|
344 for h in sorted(roots): |
22079
5dcc58649b1a
phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22070
diff
changeset
|
345 fp.write('%i %s\n' % (phase, hex(h))) |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
346 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
|
347 |
22080
37f46575d9c2
phase: attach phase to the transaction instead of the lock
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22079
diff
changeset
|
348 def _updateroots(self, phase, newroots, tr): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
349 self.phaseroots[phase] = newroots |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
350 self.invalidate() |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
351 self.dirty = True |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
352 |
22080
37f46575d9c2
phase: attach phase to the transaction instead of the lock
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22079
diff
changeset
|
353 tr.addfilegenerator('phase', ('phaseroots',), self._write) |
22940
e803186296ab
phases: inform transaction-related hooks that a phase was moved
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22894
diff
changeset
|
354 tr.hookargs['phases_moved'] = '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
|
355 |
33453
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
356 def registernew(self, repo, tr, targetphase, nodes): |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
357 repo = repo.unfiltered() |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
358 self._retractboundary(repo, tr, targetphase, nodes) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
359 if tr is not None and 'phases' in tr.changes: |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
360 phasetracking = tr.changes['phases'] |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
361 torev = repo.changelog.rev |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
362 phase = self.phase |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
363 for n in nodes: |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
364 rev = torev(n) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
365 revphase = phase(repo, rev) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
366 _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
|
367 repo.invalidatevolatilesets() |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
368 |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
369 def advanceboundary(self, repo, tr, targetphase, nodes, dryrun=None): |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
370 """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
|
371 |
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
372 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
|
373 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
374 If dryrun is True, no actions will be performed |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
375 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
376 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
|
377 """ |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
378 # 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
|
379 # phaseroots values, replace them. |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
380 if tr is None: |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
381 phasetracking = None |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
382 else: |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
383 phasetracking = tr.changes.get('phases') |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
384 |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
385 repo = repo.unfiltered() |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
386 |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
387 changes = set() # set of revisions to be changed |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
388 delroots = [] # set of root deleted by this path |
38783
e7aa113b14f7
global: use pycompat.xrange()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38683
diff
changeset
|
389 for phase in pycompat.xrange(targetphase + 1, len(allphases)): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
390 # filter nodes that are not in a compatible phase already |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
391 nodes = [n for n in nodes |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
392 if self.phase(repo, repo[n].rev()) >= phase] |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
393 if not nodes: |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
394 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
|
395 |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
396 olds = self.phaseroots[phase] |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
397 |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
398 affected = repo.revs('%ln::%ln', olds, nodes) |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
399 changes.update(affected) |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
400 if dryrun: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
401 continue |
33451
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
402 for r in affected: |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
403 _trackphasechange(phasetracking, r, self.phase(repo, r), |
e44d54260c32
phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33450
diff
changeset
|
404 targetphase) |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
405 |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
406 roots = set(ctx.node() for ctx in repo.set( |
33450
d017f1d37378
phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents:
33449
diff
changeset
|
407 'roots((%ln::) - %ld)', olds, affected)) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
408 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
|
409 self._updateroots(phase, roots, tr) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
410 # 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
|
411 delroots.extend(olds - roots) |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
412 if not dryrun: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
413 # declare deleted root in the target phase |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
414 if targetphase != 0: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
415 self._retractboundary(repo, tr, targetphase, delroots) |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
416 repo.invalidatevolatilesets() |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
417 return changes |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
418 |
22070
c1ca47204590
phase: add a transaction argument to retractboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22069
diff
changeset
|
419 def retractboundary(self, repo, tr, targetphase, nodes): |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
420 oldroots = self.phaseroots[:targetphase + 1] |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
421 if tr is None: |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
422 phasetracking = None |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
423 else: |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
424 phasetracking = tr.changes.get('phases') |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
425 repo = repo.unfiltered() |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
426 if (self._retractboundary(repo, tr, targetphase, nodes) |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
427 and phasetracking is not None): |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
428 |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
429 # find the affected revisions |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
430 new = self.phaseroots[targetphase] |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
431 old = oldroots[targetphase] |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
432 affected = set(repo.revs('(%ln::) - (%ln::)', new, old)) |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
433 |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
434 # find the phase of the affected revision |
38783
e7aa113b14f7
global: use pycompat.xrange()
Gregory Szorc <gregory.szorc@gmail.com>
parents:
38683
diff
changeset
|
435 for phase in pycompat.xrange(targetphase, -1, -1): |
33458
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
436 if phase: |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
437 roots = oldroots[phase] |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
438 revs = set(repo.revs('%ln::%ld', roots, affected)) |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
439 affected -= revs |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
440 else: # public phase |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
441 revs = affected |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
442 for r in revs: |
cf694e6422f0
phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33457
diff
changeset
|
443 _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
|
444 repo.invalidatevolatilesets() |
7b25a56366cf
phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33451
diff
changeset
|
445 |
7b25a56366cf
phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33451
diff
changeset
|
446 def _retractboundary(self, repo, tr, targetphase, nodes): |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
447 # 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
|
448 # phaseroots values, replace them. |
39299
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
449 if targetphase == internal and not supportinternal(repo): |
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
450 msg = 'this repository does not support the internal phase' |
7775c1fb8fa0
phases: enforce internal phase support
Boris Feld <boris.feld@octobus.net>
parents:
39297
diff
changeset
|
451 raise error.ProgrammingError(msg) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
452 |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
453 repo = repo.unfiltered() |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
454 currentroots = self.phaseroots[targetphase] |
33457
61714c282106
phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents:
33453
diff
changeset
|
455 finalroots = oldroots = set(currentroots) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
456 newroots = [n for n in nodes |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
457 if self.phase(repo, repo[n].rev()) < targetphase] |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
458 if newroots: |
33452
7b25a56366cf
phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents:
33451
diff
changeset
|
459 |
16659
58edd786e96f
phase: make if abort on nullid for the good reason
Patrick Mezard <patrick@mezard.eu>
parents:
16658
diff
changeset
|
460 if nullid in newroots: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25966
diff
changeset
|
461 raise error.Abort(_('cannot change null revision phase')) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
462 currentroots = currentroots.copy() |
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
463 currentroots.update(newroots) |
26909
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
464 |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
465 # 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
|
466 # retracted. |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
467 minnewroot = min(repo[n].rev() for n in newroots) |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
468 aboveroots = [n for n in currentroots |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
469 if repo[n].rev() >= minnewroot] |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
470 updatedroots = repo.set('roots(%ln::)', aboveroots) |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
471 |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
472 finalroots = set(n for n in currentroots if repo[n].rev() < |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
473 minnewroot) |
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
474 finalroots.update(ctx.node() for ctx in updatedroots) |
33457
61714c282106
phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents:
33453
diff
changeset
|
475 if finalroots != oldroots: |
26909
e36118815a39
phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents:
26587
diff
changeset
|
476 self._updateroots(targetphase, finalroots, tr) |
33457
61714c282106
phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents:
33453
diff
changeset
|
477 return True |
61714c282106
phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents:
33453
diff
changeset
|
478 return False |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
479 |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
480 def filterunknown(self, repo): |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
481 """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
|
482 |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
483 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
|
484 """ |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
485 filtered = False |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
486 nodemap = repo.changelog.nodemap # to filter unknown nodes |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
487 for phase, nodes in enumerate(self.phaseroots): |
20550
1716a2671ec7
phases: make order of debug output 'removing unknown node' deterministic
Mads Kiilerich <madski@unity3d.com>
parents:
19984
diff
changeset
|
488 missing = sorted(node for node in nodes if node not in nodemap) |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
489 if missing: |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
490 for mnode in missing: |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
491 repo.ui.debug( |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
492 'removing unknown node %s from %i-phase boundary\n' |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
493 % (short(mnode), phase)) |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
494 nodes.symmetric_difference_update(missing) |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
495 filtered = True |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
496 if filtered: |
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
497 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
|
498 # 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
|
499 # 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
|
500 # 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
|
501 # |
35309
d13526333835
phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents:
34876
diff
changeset
|
502 # 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
|
503 # 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
|
504 # "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
|
505 # (see branchmap one) |
22893
9672f0b2cdd9
phases: add invalidate function
Durham Goode <durham@fb.com>
parents:
22080
diff
changeset
|
506 self.invalidate() |
18220
767d1c602c8b
phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents:
18105
diff
changeset
|
507 |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
508 def advanceboundary(repo, tr, targetphase, nodes, 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
|
509 """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
|
510 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
511 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
|
512 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
|
513 |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
514 Simplify boundary to contains phase roots only. |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
515 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
516 If dryrun is True, no actions will be performed |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
517 |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
518 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
|
519 """ |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
520 phcache = repo._phasecache.copy() |
38218
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
521 changes = phcache.advanceboundary(repo, tr, targetphase, nodes, |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
522 dryrun=dryrun) |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
523 if not dryrun: |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
524 repo._phasecache.replace(phcache) |
36ba5dba372d
advanceboundary: add dryrun parameter
Sushil khanchi <sushilkhanchi97@gmail.com>
parents:
38158
diff
changeset
|
525 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
|
526 |
22070
c1ca47204590
phase: add a transaction argument to retractboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22069
diff
changeset
|
527 def retractboundary(repo, tr, targetphase, nodes): |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
528 """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
|
529 necessary. |
15482
a667c89e49b3
phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15481
diff
changeset
|
530 |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
531 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
|
532 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
|
533 |
a667c89e49b3
phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15481
diff
changeset
|
534 Simplify boundary to contains phase roots only.""" |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
535 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
|
536 phcache.retractboundary(repo, tr, targetphase, nodes) |
16658
6b3d31d04a69
phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents:
16657
diff
changeset
|
537 repo._phasecache.replace(phcache) |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
538 |
33453
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
539 def registernew(repo, tr, targetphase, nodes): |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
540 """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
|
541 |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
542 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
|
543 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
|
544 """ |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
545 phcache = repo._phasecache.copy() |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
546 phcache.registernew(repo, tr, targetphase, nodes) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
547 repo._phasecache.replace(phcache) |
f6b7617a85bb
phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents:
33452
diff
changeset
|
548 |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
549 def listphases(repo): |
16724
00535da82faf
phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents:
16659
diff
changeset
|
550 """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
|
551 # 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
|
552 keys = util.sortdict() |
15892
592b3d1742a1
phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15821
diff
changeset
|
553 value = '%i' % draft |
34816
e2c42f751b06
phase: filter out non-draft item in "draft root"
Boris Feld <boris.feld@octobus.net>
parents:
34710
diff
changeset
|
554 cl = repo.unfiltered().changelog |
16657
b6081c2c4647
phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents:
16626
diff
changeset
|
555 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
|
556 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
|
557 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
|
558 |
25624
f0745da75056
publishing: use new helper method
Matt Mackall <mpm@selenic.com>
parents:
25614
diff
changeset
|
559 if repo.publishing(): |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
560 # 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
|
561 # 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
|
562 # 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
|
563 # push phase boundary |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
564 # |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
565 # 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
|
566 # 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
|
567 # 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
|
568 # |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
569 # 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
|
570 # 2) repo B make changeset X public |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
571 # 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
|
572 # X as now public should |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
573 # |
16725
b0fb4f57d076
phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents:
16724
diff
changeset
|
574 # 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
|
575 # client phase data. |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
576 keys['publishing'] = 'True' |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
577 return keys |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
578 |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
579 def pushphase(repo, nhex, oldphasestr, newphasestr): |
17535 | 580 """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
|
581 repo = repo.unfiltered() |
27861
3315a9c2019c
with: use context manager for lock in pushphase
Bryan O'Sullivan <bryano@fb.com>
parents:
26909
diff
changeset
|
582 with repo.lock(): |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
583 currentphase = repo[nhex].phase() |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
584 newphase = abs(int(newphasestr)) # let's avoid negative index surprise |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
585 oldphase = abs(int(oldphasestr)) # let's avoid negative index surprise |
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
586 if currentphase == oldphase and newphase < oldphase: |
27874
4ff0e2347ae6
with: use context manager for transaction in pushphase
Bryan O'Sullivan <bryano@fb.com>
parents:
27861
diff
changeset
|
587 with repo.transaction('pushkey-phase') as tr: |
27861
3315a9c2019c
with: use context manager for lock in pushphase
Bryan O'Sullivan <bryano@fb.com>
parents:
26909
diff
changeset
|
588 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
|
589 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
|
590 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
|
591 # 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
|
592 return True |
15648
79cc89de5be1
phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15482
diff
changeset
|
593 else: |
32822
e65ff29dbeb0
pushkey: use False/True for return values from push functions
Martin von Zweigbergk <martinvonz@google.com>
parents:
32000
diff
changeset
|
594 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
|
595 |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
596 def subsetphaseheads(repo, subset): |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
597 """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
|
598 |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
599 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
|
600 head nodes. |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
601 """ |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
602 cl = repo.changelog |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
603 |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
604 headsbyphase = [[] for i in allphases] |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
605 # 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
|
606 # 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
|
607 for phase in allphases[:secret]: |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
608 revset = "heads(%%ln & %s())" % phasenames[phase] |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
609 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
|
610 return headsbyphase |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
611 |
34321
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34320
diff
changeset
|
612 def updatephases(repo, trgetter, headsbyphase): |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
613 """Updates the repo with the given phase heads""" |
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
614 # Now advance phase boundaries of all but secret phase |
34321
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34320
diff
changeset
|
615 # |
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34320
diff
changeset
|
616 # 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
|
617 # 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
|
618 |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
619 for phase in allphases[:-1]: |
39293
278eb4541758
phases: simplify revset in updatephases
Boris Feld <boris.feld@octobus.net>
parents:
39275
diff
changeset
|
620 revset = '%ln - _phase(%s)' |
278eb4541758
phases: simplify revset in updatephases
Boris Feld <boris.feld@octobus.net>
parents:
39275
diff
changeset
|
621 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
|
622 if heads: |
4ef472b975ff
bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents:
34320
diff
changeset
|
623 advanceboundary(repo, trgetter(), phase, heads) |
33031
e8c8d81eb864
bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents:
32822
diff
changeset
|
624 |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
625 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
|
626 """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
|
627 |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
628 * 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
|
629 * 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
|
630 |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
631 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
|
632 """ |
18002
9bc5873e52af
clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17979
diff
changeset
|
633 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
|
634 # 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
|
635 draftroots = [] |
15902
4252d9f08d7e
phases: use nodemap to check for missing nodes
Sune Foldager <cryo@cyanite.org>
parents:
15892
diff
changeset
|
636 nodemap = repo.changelog.nodemap # to filter unknown nodes |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
637 for nhex, phase in roots.iteritems(): |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
638 if nhex == 'publishing': # ignore data related to publish option |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
639 continue |
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
640 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
|
641 phase = int(phase) |
28174
f16b84b1e40e
phases: use constants for phase values
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27874
diff
changeset
|
642 if phase == public: |
15892
592b3d1742a1
phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15821
diff
changeset
|
643 if node != nullid: |
15953
52dc2b33d0be
phase: fix warning text from invalid remote phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15948
diff
changeset
|
644 repo.ui.warn(_('ignoring inconsistent public root' |
52dc2b33d0be
phase: fix warning text from invalid remote phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15948
diff
changeset
|
645 ' from remote: %s\n') % nhex) |
28174
f16b84b1e40e
phases: use constants for phase values
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27874
diff
changeset
|
646 elif phase == draft: |
15902
4252d9f08d7e
phases: use nodemap to check for missing nodes
Sune Foldager <cryo@cyanite.org>
parents:
15892
diff
changeset
|
647 if node in nodemap: |
15892
592b3d1742a1
phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15821
diff
changeset
|
648 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
|
649 else: |
15953
52dc2b33d0be
phase: fix warning text from invalid remote phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15948
diff
changeset
|
650 repo.ui.warn(_('ignoring unexpected root from remote: %i %s\n') |
52dc2b33d0be
phase: fix warning text from invalid remote phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15948
diff
changeset
|
651 % (phase, nhex)) |
15649
ca7c4254a21a
phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15648
diff
changeset
|
652 # compute heads |
15954
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
653 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
|
654 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
|
655 |
34819
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
656 class remotephasessummary(object): |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
657 """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
|
658 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
659 :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
|
660 :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
|
661 :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
|
662 :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
|
663 """ |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
664 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
665 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
|
666 unfi = repo.unfiltered() |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
667 self._allremoteroots = remoteroots |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
668 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
669 self.publishing = remoteroots.get('publishing', False) |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
670 |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
671 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
|
672 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
|
673 # Get the list of all "heads" revs draft on remote |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
674 dheads = unfi.set('heads(%ln::%ln)', self.draftroots, remotesubset) |
eb6375651974
phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents:
34816
diff
changeset
|
675 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
|
676 |
15954
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
677 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
|
678 """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
|
679 |
b345f851d056
phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
15953
diff
changeset
|
680 * `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
|
681 * `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
|
682 # prevent an import cycle |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
683 # 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
|
684 from . import dagop |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
685 |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
686 repo = repo.unfiltered() |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
687 cl = repo.changelog |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
688 rev = cl.nodemap.get |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
689 if not roots: |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
690 return heads |
39199
d8ac2ad55d9c
phases: fix `nullid` reference in newheads
Boris Feld <boris.feld@octobus.net>
parents:
39146
diff
changeset
|
691 if not heads or heads == [nullid]: |
39146
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
692 return [] |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
693 # The logic operated on revisions, convert arguments early for convenience |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
694 new_heads = set(rev(n) for n in heads if n != nullid) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
695 roots = [rev(n) for n in roots] |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
696 # compute the area we need to remove |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
697 affected_zone = repo.revs("(%ld::%ld)", roots, new_heads) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
698 # 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
|
699 new_heads.difference_update(affected_zone) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
700 # 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
|
701 # They might be new heads |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
702 candidates = repo.revs("parents(%ld + (%ld and merge())) and not null", |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
703 roots, affected_zone) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
704 candidates -= affected_zone |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
705 if new_heads or candidates: |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
706 # 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
|
707 new_heads.update(candidates) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
708 prunestart = repo.revs("parents(%ld) and not null", new_heads) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
709 pruned = dagop.reachableroots(repo, candidates, prunestart) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
710 new_heads.difference_update(pruned) |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
711 |
f736fdbe546a
remotephase: avoid full changelog iteration (issue5964)
Boris Feld <boris.feld@octobus.net>
parents:
39141
diff
changeset
|
712 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
|
713 |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
714 def newcommitphase(ui): |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
715 """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
|
716 |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
717 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
|
718 |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
719 """ |
34563
1faa34347b24
configitems: update default value of 'phases.new-commit'
Boris Feld <boris.feld@octobus.net>
parents:
34321
diff
changeset
|
720 v = ui.config('phases', '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
|
721 try: |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
722 return phasenames.index(v) |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
723 except ValueError: |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
724 try: |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
725 return int(v) |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
726 except ValueError: |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
727 msg = _("phases.new-commit: not a valid phase name ('%s')") |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
728 raise error.ConfigError(msg % v) |
308406677e9d
phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
16025
diff
changeset
|
729 |
17671
fdd0fc046cf1
clfilter: introduce a `hassecret` function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17537
diff
changeset
|
730 def hassecret(repo): |
fdd0fc046cf1
clfilter: introduce a `hassecret` function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17537
diff
changeset
|
731 """utility function that check if a repo have any secret changeset.""" |
fdd0fc046cf1
clfilter: introduce a `hassecret` function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17537
diff
changeset
|
732 return bool(repo._phasecache.phaseroots[2]) |
34710
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
733 |
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
734 def preparehookargs(node, old, new): |
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
735 if old is None: |
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
736 old = '' |
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
737 else: |
34876
eb1b964b354b
phases: pass phase names to hooks instead of internal values
Kevin Bullock <kbullock+mercurial@ringworld.org>
parents:
34819
diff
changeset
|
738 old = phasenames[old] |
34710
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
739 return {'node': node, |
cdf833d7de98
phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents:
34563
diff
changeset
|
740 'oldphase': old, |
34876
eb1b964b354b
phases: pass phase names to hooks instead of internal values
Kevin Bullock <kbullock+mercurial@ringworld.org>
parents:
34819
diff
changeset
|
741 'phase': phasenames[new]} |