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