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