annotate mercurial/phases.py @ 36309:94a1ff16f362

debuginstall: do not parse editor command in posix way on Windows An editor command is executed by a system shell, which is cmd.exe on Windows.
author Yuya Nishihara <yuya@tcha.org>
date Sat, 17 Feb 2018 13:13:04 +0900
parents 56745e58df07
children ab81e5a8fba5
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
1 """ Mercurial phases support code
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
2
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
3 ---
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
4
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
5 Copyright 2011 Pierre-Yves David <pierre-yves.david@ens-lyon.org>
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
6 Logilab SA <contact@logilab.fr>
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
7 Augie Fackler <durin42@gmail.com>
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
8
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
9 This software may be used and distributed according to the terms
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
10 of the GNU General Public License version 2 or any later version.
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
11
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
12 ---
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
13
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
14 This module implements most phase logic in mercurial.
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
15
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
16
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
17 Basic Concept
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
18 =============
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
19
16724
00535da82faf phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents: 16659
diff changeset
20 A 'changeset phase' is an indicator that tells us how a changeset is
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
21 manipulated and communicated. The details of each phase is described
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
22 below, here we describe the properties they have in common.
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
23
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
24 Like bookmarks, phases are not stored in history and thus are not
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
25 permanent and leave no audit trail.
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
26
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
27 First, no changeset can be in two phases at once. Phases are ordered,
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
28 so they can be considered from lowest to highest. The default, lowest
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
29 phase is 'public' - this is the normal phase of existing changesets. A
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
30 child changeset can not be in a lower phase than its parents.
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
31
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
32 These phases share a hierarchy of traits:
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
33
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
34 immutable shared
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
35 public: X X
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
36 draft: X
15705
e34f4d1f0dbb phases: update doc to mention secret phase
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15697
diff changeset
37 secret:
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
38
16724
00535da82faf phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents: 16659
diff changeset
39 Local commits are draft by default.
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
40
16724
00535da82faf phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents: 16659
diff changeset
41 Phase Movement and Exchange
00535da82faf phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents: 16659
diff changeset
42 ===========================
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
43
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
44 Phase data is exchanged by pushkey on pull and push. Some servers have
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
45 a publish option set, we call such a server a "publishing server".
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
46 Pushing a draft changeset to a publishing server changes the phase to
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
47 public.
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
48
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
49 A small list of fact/rules define the exchange of phase:
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
50
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
51 * old client never changes server states
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
52 * pull never changes server states
16724
00535da82faf phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents: 16659
diff changeset
53 * publish and old server changesets are seen as public by client
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
54 * any secret changeset seen in another repository is lowered to at
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
55 least draft
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
56
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
57 Here is the final table summing up the 49 possible use cases of phase
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
58 exchange:
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
59
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
60 server
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
61 old publish non-publish
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
62 N X N D P N D P
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
63 old client
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
64 pull
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
65 N - X/X - X/D X/P - X/D X/P
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
66 X - X/X - X/D X/P - X/D X/P
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
67 push
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
68 X X/X X/X X/P X/P X/P X/D X/D X/P
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
69 new client
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
70 pull
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
71 N - P/X - P/D P/P - D/D P/P
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
72 D - P/X - P/D P/P - D/D P/P
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
73 P - P/X - P/D P/P - P/D P/P
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
74 push
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
75 D P/X P/X P/P P/P P/P D/D D/D P/P
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
76 P P/X P/X P/P P/P P/P P/P P/P P/P
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
77
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
78 Legend:
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
79
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
80 A/B = final state on client / state on server
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
81
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
82 * N = new/not present,
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
83 * P = public,
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
84 * D = draft,
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
85 * X = not tracked (i.e., the old client or server has no internal
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
86 way of recording the phase.)
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
87
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
88 passive = only pushes
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
89
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
90
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
91 A cell here can be read like this:
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
92
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
93 "When a new client pushes a draft changeset (D) to a publishing
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
94 server where it's not present (N), it's marked public on both
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
95 sides (P/P)."
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
96
16724
00535da82faf phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents: 16659
diff changeset
97 Note: old client behave as a publishing server with draft only content
15659
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
98 - other people see it as public
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
99 - content is pushed as draft
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
100
7fba5a245acc phases: change publish behavior to only alter behavior when server.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15649
diff changeset
101 """
15417
5261140d9322 phases: Minimal first add.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
diff changeset
102
25966
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
103 from __future__ import absolute_import
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
104
15419
ccb7de21625a phases: handle errors other than ENOENT appropriately
Matt Mackall <mpm@selenic.com>
parents: 15418
diff changeset
105 import errno
34319
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
106 import struct
25966
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
107
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
108 from .i18n import _
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
109 from .node import (
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
110 bin,
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
111 hex,
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
112 nullid,
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
113 nullrev,
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
114 short,
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
115 )
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
116 from . import (
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
117 error,
35309
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
118 pycompat,
31016
bf81d3b7b2ba phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents: 30634
diff changeset
119 smartset,
31053
6afd8a87a657 phases: check HG_PENDING strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 31016
diff changeset
120 txnutil,
32000
511a62669f1b phases: emit phases to pushkey protocol in deterministic order
Gregory Szorc <gregory.szorc@gmail.com>
parents: 31342
diff changeset
121 util,
25966
f14cea32e1d4 phases: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25660
diff changeset
122 )
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15417
diff changeset
123
34319
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
124 _fphasesentry = struct.Struct('>i20s')
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
125
15818
57241845a4bb phases: store phase values in constant instead of using raw integer
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15705
diff changeset
126 allphases = public, draft, secret = range(3)
15417
5261140d9322 phases: Minimal first add.
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
diff changeset
127 trackedphases = allphases[1:]
15821
e3ee8bf5d0cc phases: add list of string to access phase name
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15818
diff changeset
128 phasenames = ['public', 'draft', 'secret']
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15417
diff changeset
129
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
130 def _readroots(repo, phasedefaults=None):
16625
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
131 """Read phase roots from disk
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
132
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
133 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
134 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
135 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
136 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
137
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
138 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
139 what is being stored.
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
140 """
18002
9bc5873e52af clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17979
diff changeset
141 repo = repo.unfiltered()
16625
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
142 dirty = False
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15417
diff changeset
143 roots = [set() for i in allphases]
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15417
diff changeset
144 try:
31053
6afd8a87a657 phases: check HG_PENDING strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 31016
diff changeset
145 f, pending = txnutil.trypending(repo.root, repo.svfs, 'phaseroots')
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15417
diff changeset
146 try:
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15417
diff changeset
147 for line in f:
16588
72319bfd7966 phases: line.strip().split() == line.split()
Martin Geisler <mg@aragost.com>
parents: 16535
diff changeset
148 phase, nh = line.split()
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15417
diff changeset
149 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
150 finally:
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15417
diff changeset
151 f.close()
25660
328739ea70c3 global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25624
diff changeset
152 except IOError as inst:
15419
ccb7de21625a phases: handle errors other than ENOENT appropriately
Matt Mackall <mpm@selenic.com>
parents: 15418
diff changeset
153 if inst.errno != errno.ENOENT:
ccb7de21625a phases: handle errors other than ENOENT appropriately
Matt Mackall <mpm@selenic.com>
parents: 15418
diff changeset
154 raise
16625
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
155 if phasedefaults:
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
156 for f in phasedefaults:
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
157 roots = f(repo, roots)
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
158 dirty = True
df9df747070d phases: stop modifying localrepo in readroots()
Patrick Mezard <patrick@mezard.eu>
parents: 16624
diff changeset
159 return roots, dirty
15418
cf729af26963 phases: basic I/O logic
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15417
diff changeset
160
34319
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
161 def binaryencode(phasemapping):
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
162 """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
163
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
164 Since phases are integer the mapping is actually a python list:
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
165 [[PUBLIC_HEADS], [DRAFTS_HEADS], [SECRET_HEADS]]
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
166 """
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
167 binarydata = []
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
168 for phase, nodes in enumerate(phasemapping):
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
169 for head in nodes:
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
170 binarydata.append(_fphasesentry.pack(phase, head))
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
171 return ''.join(binarydata)
5779d096a696 phases: move binary encoding into a reusable function
Boris Feld <boris.feld@octobus.net>
parents: 33460
diff changeset
172
34320
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
173 def binarydecode(stream):
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
174 """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
175
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
176 Since phases are integer the mapping is actually a python list."""
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
177 headsbyphase = [[] for i in allphases]
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
178 entrysize = _fphasesentry.size
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
179 while True:
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
180 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
181 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
182 if entry:
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
183 raise error.Abort(_('bad phase-heads stream'))
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
184 break
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
185 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
186 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
187 return headsbyphase
12c42bcd4133 phases: move the binary decoding function in the phases module
Boris Feld <boris.feld@octobus.net>
parents: 34319
diff changeset
188
33451
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
189 def _trackphasechange(data, rev, old, new):
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
190 """add a phase move the <data> dictionnary
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
191
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
192 If data is None, nothing happens.
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
193 """
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
194 if data is None:
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
195 return
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
196 existing = data.get(rev)
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
197 if existing is not None:
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
198 old = existing[0]
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
199 data[rev] = (old, new)
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
200
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
201 class phasecache(object):
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
202 def __init__(self, repo, phasedefaults, _load=True):
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
203 if _load:
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
204 # Cheap trick to allow shallow-copy without copy module
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
205 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
206 self._loadedrevslen = 0
25190
22438cfd11b5 phases: add set per phase in C phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 24599
diff changeset
207 self._phasesets = None
18220
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
208 self.filterunknown(repo)
23878
37a92908a382 localrepo: remove all external users of localrepo.sopener
Angel Ezquerra <angel.ezquerra@gmail.com>
parents: 23631
diff changeset
209 self.opener = repo.svfs
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
210
35330
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35309
diff changeset
211 def getrevset(self, repo, phases, subset=None):
31016
bf81d3b7b2ba phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents: 30634
diff changeset
212 """return a smartset for the given phases"""
bf81d3b7b2ba phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents: 30634
diff changeset
213 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
214 phases = set(phases)
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
215 if public not in phases:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
216 # fast path: _phasesets contains the interesting sets,
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
217 # might only need a union and post-filtering.
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
218 if len(phases) == 1:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
219 [p] = phases
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
220 revs = self._phasesets[p]
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
221 else:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
222 revs = set.union(*[self._phasesets[p] for p in phases])
31016
bf81d3b7b2ba phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents: 30634
diff changeset
223 if repo.changelog.filteredrevs:
bf81d3b7b2ba phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents: 30634
diff changeset
224 revs = revs - repo.changelog.filteredrevs
35330
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35309
diff changeset
225 if subset is None:
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35309
diff changeset
226 return smartset.baseset(revs)
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35309
diff changeset
227 else:
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35309
diff changeset
228 return subset & smartset.baseset(revs)
31016
bf81d3b7b2ba phases: add a getrevset method to phasecache
Jun Wu <quark@fb.com>
parents: 30634
diff changeset
229 else:
35309
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
230 phases = set(allphases).difference(phases)
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
231 if not phases:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
232 return smartset.fullreposet(repo)
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
233 if len(phases) == 1:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
234 [p] = phases
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
235 revs = self._phasesets[p]
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
236 else:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
237 revs = set.union(*[self._phasesets[p] for p in phases])
35330
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35309
diff changeset
238 if subset is None:
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35309
diff changeset
239 subset = smartset.fullreposet(repo)
35309
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
240 if not revs:
35330
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35309
diff changeset
241 return subset
0c1aff6d73a7 revset: use phasecache.getrevset to calculate public()
Jun Wu <quark@fb.com>
parents: 35309
diff changeset
242 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
243
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
244 def copy(self):
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
245 # Shallow copy meant to ensure isolation in
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
246 # advance/retractboundary(), nothing more.
23631
b8260abfeb7d bundlerepo: implement safe phasecache
Eric Sumner <ericsumner@fb.com>
parents: 23361
diff changeset
247 ph = self.__class__(None, None, _load=False)
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
248 ph.phaseroots = self.phaseroots[:]
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
249 ph.dirty = self.dirty
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
250 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
251 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
252 ph._phasesets = self._phasesets
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
253 return ph
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
254
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
255 def replace(self, phcache):
25613
a13c18c14ade phase: document the replace method
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25611
diff changeset
256 """replace all values in 'self' with content of phcache"""
35441
98cc121099fe phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents: 35330
diff changeset
257 for a in ('phaseroots', 'dirty', 'opener', '_loadedrevslen',
35309
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
258 '_phasesets'):
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
259 setattr(self, a, getattr(phcache, a))
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
260
24599
2a73829ebe17 phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 24520
diff changeset
261 def _getphaserevsnative(self, repo):
24444
27e3ba73fbb1 phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 23878
diff changeset
262 repo = repo.unfiltered()
27e3ba73fbb1 phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 23878
diff changeset
263 nativeroots = []
27e3ba73fbb1 phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 23878
diff changeset
264 for phase in trackedphases:
27e3ba73fbb1 phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 23878
diff changeset
265 nativeroots.append(map(repo.changelog.rev, self.phaseroots[phase]))
25527
262e6ad93885 phases: really fix native phase computation
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25190
diff changeset
266 return repo.changelog.computephases(nativeroots)
24444
27e3ba73fbb1 phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 23878
diff changeset
267
24599
2a73829ebe17 phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 24520
diff changeset
268 def _computephaserevspure(self, repo):
24519
de3acfabaddc phases: move pure phase computation in a function
Laurent Charignon <lcharignon@fb.com>
parents: 24444
diff changeset
269 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
270 cl = repo.changelog
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
271 self._phasesets = [set() for phase in allphases]
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
272 roots = pycompat.maplist(cl.rev, self.phaseroots[secret])
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
273 if roots:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
274 ps = set(cl.descendants(roots))
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
275 for root in roots:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
276 ps.add(root)
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
277 self._phasesets[secret] = ps
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
278 roots = pycompat.maplist(cl.rev, self.phaseroots[draft])
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
279 if roots:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
280 ps = set(cl.descendants(roots))
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
281 for root in roots:
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
282 ps.add(root)
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
283 ps.difference_update(self._phasesets[secret])
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
284 self._phasesets[draft] = ps
35441
98cc121099fe phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents: 35330
diff changeset
285 self._loadedrevslen = len(cl)
24519
de3acfabaddc phases: move pure phase computation in a function
Laurent Charignon <lcharignon@fb.com>
parents: 24444
diff changeset
286
25611
d89045a66e01 phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25594
diff changeset
287 def loadphaserevs(self, repo):
d89045a66e01 phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25594
diff changeset
288 """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
289 if self._phasesets is None:
24444
27e3ba73fbb1 phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 23878
diff changeset
290 try:
31152
b7cef987356d phases: remove experimental.nativephaseskillswitch
Jun Wu <quark@fb.com>
parents: 31053
diff changeset
291 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
292 self._loadedrevslen, self._phasesets = res
24444
27e3ba73fbb1 phase: default to C implementation for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 23878
diff changeset
293 except AttributeError:
24599
2a73829ebe17 phases: make two functions private for phase computation
Laurent Charignon <lcharignon@fb.com>
parents: 24520
diff changeset
294 self._computephaserevspure(repo)
22894
c40be72dc177 phases: move root phase assignment to it's own function
Durham Goode <durham@fb.com>
parents: 22893
diff changeset
295
22893
9672f0b2cdd9 phases: add invalidate function
Durham Goode <durham@fb.com>
parents: 22080
diff changeset
296 def invalidate(self):
35442
56745e58df07 phases: initialize number of loaded revisions to 0
Yuya Nishihara <yuya@tcha.org>
parents: 35441
diff changeset
297 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
298 self._phasesets = None
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
299
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
300 def phase(self, repo, rev):
35309
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
301 # 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
302 # if necessary. The repository instance is not stored in
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
303 # phasecache to avoid reference cycles. The changelog instance
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
304 # is not stored because it is a filecache() property and can
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
305 # be replaced without us being notified.
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
306 if rev == nullrev:
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
307 return public
19984
7d5e7799a29f rebase: fix rebase aborts when 'tip-1' is public (issue4082)
Durham Goode <durham@fb.com>
parents: 19951
diff changeset
308 if rev < nullrev:
7d5e7799a29f rebase: fix rebase aborts when 'tip-1' is public (issue4082)
Durham Goode <durham@fb.com>
parents: 19951
diff changeset
309 raise ValueError(_('cannot lookup negative revision'))
35441
98cc121099fe phases: rename _phasemaxrev to _loadedrevslen to clarify it isn't max value
Yuya Nishihara <yuya@tcha.org>
parents: 35330
diff changeset
310 if rev >= self._loadedrevslen:
22893
9672f0b2cdd9 phases: add invalidate function
Durham Goode <durham@fb.com>
parents: 22080
diff changeset
311 self.invalidate()
25611
d89045a66e01 phase: rename getphaserevs to loadphaserevs
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25594
diff changeset
312 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
313 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
314 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
315 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
316 return public
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
317
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
318 def write(self):
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
319 if not self.dirty:
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
320 return
29303
3a2357c31d2a phases: make writing phaseroots file out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 28174
diff changeset
321 f = self.opener('phaseroots', 'w', atomictemp=True, checkambig=True)
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
322 try:
22079
5dcc58649b1a phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22070
diff changeset
323 self._write(f)
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
324 finally:
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
325 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
326
5dcc58649b1a phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22070
diff changeset
327 def _write(self, fp):
5dcc58649b1a phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22070
diff changeset
328 for phase, roots in enumerate(self.phaseroots):
5dcc58649b1a phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22070
diff changeset
329 for h in roots:
5dcc58649b1a phase: extract the phaseroots serialization in a dedicated method
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22070
diff changeset
330 fp.write('%i %s\n' % (phase, hex(h)))
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
331 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
332
22080
37f46575d9c2 phase: attach phase to the transaction instead of the lock
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22079
diff changeset
333 def _updateroots(self, phase, newroots, tr):
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
334 self.phaseroots[phase] = newroots
22893
9672f0b2cdd9 phases: add invalidate function
Durham Goode <durham@fb.com>
parents: 22080
diff changeset
335 self.invalidate()
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
336 self.dirty = True
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
337
22080
37f46575d9c2 phase: attach phase to the transaction instead of the lock
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22079
diff changeset
338 tr.addfilegenerator('phase', ('phaseroots',), self._write)
22940
e803186296ab phases: inform transaction-related hooks that a phase was moved
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22894
diff changeset
339 tr.hookargs['phases_moved'] = '1'
22080
37f46575d9c2 phase: attach phase to the transaction instead of the lock
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22079
diff changeset
340
33453
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
341 def registernew(self, repo, tr, targetphase, nodes):
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
342 repo = repo.unfiltered()
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
343 self._retractboundary(repo, tr, targetphase, nodes)
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
344 if tr is not None and 'phases' in tr.changes:
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
345 phasetracking = tr.changes['phases']
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
346 torev = repo.changelog.rev
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
347 phase = self.phase
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
348 for n in nodes:
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
349 rev = torev(n)
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
350 revphase = phase(repo, rev)
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
351 _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
352 repo.invalidatevolatilesets()
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
353
22069
616a455b02ca phase: add a transaction argument to advanceboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22052
diff changeset
354 def advanceboundary(self, repo, tr, targetphase, nodes):
33450
d017f1d37378 phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents: 33449
diff changeset
355 """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
356
d017f1d37378 phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents: 33449
diff changeset
357 Nodes with a phase lower than 'targetphase' are not affected.
d017f1d37378 phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents: 33449
diff changeset
358 """
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
359 # 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
360 # phaseroots values, replace them.
33451
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
361 if tr is None:
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
362 phasetracking = None
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
363 else:
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
364 phasetracking = tr.changes.get('phases')
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
365
18002
9bc5873e52af clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17979
diff changeset
366 repo = repo.unfiltered()
33451
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
367
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
368 delroots = [] # set of root deleted by this path
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
369 for phase in xrange(targetphase + 1, len(allphases)):
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
370 # filter nodes that are not in a compatible phase already
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
371 nodes = [n for n in nodes
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
372 if self.phase(repo, repo[n].rev()) >= phase]
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
373 if not nodes:
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
374 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
375
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
376 olds = self.phaseroots[phase]
33451
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
377
33450
d017f1d37378 phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents: 33449
diff changeset
378 affected = repo.revs('%ln::%ln', olds, nodes)
33451
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
379 for r in affected:
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
380 _trackphasechange(phasetracking, r, self.phase(repo, r),
e44d54260c32 phases: track phase movements in 'advanceboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33450
diff changeset
381 targetphase)
33450
d017f1d37378 phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents: 33449
diff changeset
382
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
383 roots = set(ctx.node() for ctx in repo.set(
33450
d017f1d37378 phases: extract the intermediate set of affected revs
Boris Feld <boris.feld@octobus.net>
parents: 33449
diff changeset
384 'roots((%ln::) - %ld)', olds, affected))
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
385 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
386 self._updateroots(phase, roots, tr)
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
387 # 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
388 delroots.extend(olds - roots)
33449
5747967e257c phase: put retractboundary out of the loop in advanceboundary
Boris Feld <boris.feld@octobus.net>
parents: 33409
diff changeset
389 # declare deleted root in the target phase
5747967e257c phase: put retractboundary out of the loop in advanceboundary
Boris Feld <boris.feld@octobus.net>
parents: 33409
diff changeset
390 if targetphase != 0:
33452
7b25a56366cf phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33451
diff changeset
391 self._retractboundary(repo, tr, targetphase, delroots)
18105
312262ebc223 cache: group obscache and revsfiltercache invalidation in a single function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 18101
diff changeset
392 repo.invalidatevolatilesets()
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
393
22070
c1ca47204590 phase: add a transaction argument to retractboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22069
diff changeset
394 def retractboundary(self, repo, tr, targetphase, nodes):
33458
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
395 oldroots = self.phaseroots[:targetphase + 1]
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
396 if tr is None:
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
397 phasetracking = None
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
398 else:
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
399 phasetracking = tr.changes.get('phases')
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
400 repo = repo.unfiltered()
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
401 if (self._retractboundary(repo, tr, targetphase, nodes)
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
402 and phasetracking is not None):
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
403
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
404 # find the affected revisions
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
405 new = self.phaseroots[targetphase]
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
406 old = oldroots[targetphase]
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
407 affected = set(repo.revs('(%ln::) - (%ln::)', new, old))
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
408
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
409 # find the phase of the affected revision
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
410 for phase in xrange(targetphase, -1, -1):
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
411 if phase:
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
412 roots = oldroots[phase]
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
413 revs = set(repo.revs('%ln::%ld', roots, affected))
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
414 affected -= revs
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
415 else: # public phase
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
416 revs = affected
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
417 for r in revs:
cf694e6422f0 phases: track phase changes from 'retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33457
diff changeset
418 _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
419 repo.invalidatevolatilesets()
7b25a56366cf phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33451
diff changeset
420
7b25a56366cf phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33451
diff changeset
421 def _retractboundary(self, repo, tr, targetphase, nodes):
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
422 # 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
423 # phaseroots values, replace them.
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
424
18002
9bc5873e52af clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17979
diff changeset
425 repo = repo.unfiltered()
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
426 currentroots = self.phaseroots[targetphase]
33457
61714c282106 phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents: 33453
diff changeset
427 finalroots = oldroots = set(currentroots)
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
428 newroots = [n for n in nodes
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
429 if self.phase(repo, repo[n].rev()) < targetphase]
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
430 if newroots:
33452
7b25a56366cf phases: extract the core of boundary retraction in '_retractboundary'
Boris Feld <boris.feld@octobus.net>
parents: 33451
diff changeset
431
16659
58edd786e96f phase: make if abort on nullid for the good reason
Patrick Mezard <patrick@mezard.eu>
parents: 16658
diff changeset
432 if nullid in newroots:
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 25966
diff changeset
433 raise error.Abort(_('cannot change null revision phase'))
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
434 currentroots = currentroots.copy()
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
435 currentroots.update(newroots)
26909
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
436
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
437 # 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
438 # retracted.
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
439 minnewroot = min(repo[n].rev() for n in newroots)
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
440 aboveroots = [n for n in currentroots
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
441 if repo[n].rev() >= minnewroot]
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
442 updatedroots = repo.set('roots(%ln::)', aboveroots)
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
443
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
444 finalroots = set(n for n in currentroots if repo[n].rev() <
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
445 minnewroot)
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
446 finalroots.update(ctx.node() for ctx in updatedroots)
33457
61714c282106 phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents: 33453
diff changeset
447 if finalroots != oldroots:
26909
e36118815a39 phase: improve retractboundary perf
Durham Goode <durham@fb.com>
parents: 26587
diff changeset
448 self._updateroots(targetphase, finalroots, tr)
33457
61714c282106 phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents: 33453
diff changeset
449 return True
61714c282106 phases: detect when boundaries has been actually retracted
Boris Feld <boris.feld@octobus.net>
parents: 33453
diff changeset
450 return False
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
451
18220
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
452 def filterunknown(self, repo):
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
453 """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
454
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
455 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
456 """
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
457 filtered = False
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
458 nodemap = repo.changelog.nodemap # to filter unknown nodes
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
459 for phase, nodes in enumerate(self.phaseroots):
20550
1716a2671ec7 phases: make order of debug output 'removing unknown node' deterministic
Mads Kiilerich <madski@unity3d.com>
parents: 19984
diff changeset
460 missing = sorted(node for node in nodes if node not in nodemap)
18220
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
461 if missing:
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
462 for mnode in missing:
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
463 repo.ui.debug(
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
464 'removing unknown node %s from %i-phase boundary\n'
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
465 % (short(mnode), phase))
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
466 nodes.symmetric_difference_update(missing)
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
467 filtered = True
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
468 if filtered:
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
469 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
470 # 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
471 # 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
472 # 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
473 #
35309
d13526333835 phases: drop the list with phase of each rev, always comput phase sets
Joerg Sonnenberger <joerg@bec.de>
parents: 34876
diff changeset
474 # 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
475 # 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
476 # "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
477 # (see branchmap one)
22893
9672f0b2cdd9 phases: add invalidate function
Durham Goode <durham@fb.com>
parents: 22080
diff changeset
478 self.invalidate()
18220
767d1c602c8b phases: make _filterunknown a member function of phasecache
Idan Kamara <idankk86@gmail.com>
parents: 18105
diff changeset
479
22069
616a455b02ca phase: add a transaction argument to advanceboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22052
diff changeset
480 def advanceboundary(repo, tr, targetphase, nodes):
15454
5a7dde5adec8 phases: add a moveboundary function to move phases boundaries
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15419
diff changeset
481 """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
482
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
483 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
484 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
485
15482
a667c89e49b3 phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15481
diff changeset
486 Simplify boundary to contains phase roots only."""
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
487 phcache = repo._phasecache.copy()
22069
616a455b02ca phase: add a transaction argument to advanceboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22052
diff changeset
488 phcache.advanceboundary(repo, tr, targetphase, nodes)
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
489 repo._phasecache.replace(phcache)
15482
a667c89e49b3 phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15481
diff changeset
490
22070
c1ca47204590 phase: add a transaction argument to retractboundary
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 22069
diff changeset
491 def retractboundary(repo, tr, targetphase, nodes):
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
492 """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
493 necessary.
15482
a667c89e49b3 phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15481
diff changeset
494
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
495 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
496 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
497
a667c89e49b3 phases: add retractboundary function to move boundary backward
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15481
diff changeset
498 Simplify boundary to contains phase roots only."""
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
499 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
500 phcache.retractboundary(repo, tr, targetphase, nodes)
16658
6b3d31d04a69 phases: make advance/retractboundary() atomic
Patrick Mezard <patrick@mezard.eu>
parents: 16657
diff changeset
501 repo._phasecache.replace(phcache)
15648
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
502
33453
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
503 def registernew(repo, tr, targetphase, nodes):
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
504 """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
505
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
506 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
507 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
508 """
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
509 phcache = repo._phasecache.copy()
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
510 phcache.registernew(repo, tr, targetphase, nodes)
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
511 repo._phasecache.replace(phcache)
f6b7617a85bb phases: add a 'registernew' method to set new phases
Boris Feld <boris.feld@octobus.net>
parents: 33452
diff changeset
512
15648
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
513 def listphases(repo):
16724
00535da82faf phases: fix typos in docstrings
Martin Geisler <martin@geisler.net>
parents: 16659
diff changeset
514 """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
515 # 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
516 keys = util.sortdict()
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15821
diff changeset
517 value = '%i' % draft
34816
e2c42f751b06 phase: filter out non-draft item in "draft root"
Boris Feld <boris.feld@octobus.net>
parents: 34710
diff changeset
518 cl = repo.unfiltered().changelog
16657
b6081c2c4647 phases: introduce phasecache
Patrick Mezard <patrick@mezard.eu>
parents: 16626
diff changeset
519 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
520 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
521 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
522
25624
f0745da75056 publishing: use new helper method
Matt Mackall <mpm@selenic.com>
parents: 25614
diff changeset
523 if repo.publishing():
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
524 # 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
525 # 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
526 # 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
527 # push phase boundary
15648
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
528 #
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
529 # 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
530 # 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
531 # 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
532 #
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
533 # 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
534 # 2) repo B make changeset X public
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
535 # 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
536 # X as now public should
15648
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
537 #
16725
b0fb4f57d076 phases: wrap docstrings at 70 characters
Martin Geisler <martin@geisler.net>
parents: 16724
diff changeset
538 # 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
539 # client phase data.
15648
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
540 keys['publishing'] = 'True'
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
541 return keys
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
542
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
543 def pushphase(repo, nhex, oldphasestr, newphasestr):
17535
63e302be813f en-us: serialization
timeless@mozdev.org
parents: 17205
diff changeset
544 """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
545 repo = repo.unfiltered()
27861
3315a9c2019c with: use context manager for lock in pushphase
Bryan O'Sullivan <bryano@fb.com>
parents: 26909
diff changeset
546 with repo.lock():
15648
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
547 currentphase = repo[nhex].phase()
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
548 newphase = abs(int(newphasestr)) # let's avoid negative index surprise
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
549 oldphase = abs(int(oldphasestr)) # let's avoid negative index surprise
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
550 if currentphase == oldphase and newphase < oldphase:
27874
4ff0e2347ae6 with: use context manager for transaction in pushphase
Bryan O'Sullivan <bryano@fb.com>
parents: 27861
diff changeset
551 with repo.transaction('pushkey-phase') as tr:
27861
3315a9c2019c with: use context manager for lock in pushphase
Bryan O'Sullivan <bryano@fb.com>
parents: 26909
diff changeset
552 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
553 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
554 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
555 # 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
556 return True
15648
79cc89de5be1 phases: add basic pushkey support
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15482
diff changeset
557 else:
32822
e65ff29dbeb0 pushkey: use False/True for return values from push functions
Martin von Zweigbergk <martinvonz@google.com>
parents: 32000
diff changeset
558 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
559
33031
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
560 def subsetphaseheads(repo, subset):
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
561 """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
562
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
563 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
564 head nodes.
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
565 """
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
566 cl = repo.changelog
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
567
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
568 headsbyphase = [[] for i in allphases]
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
569 # 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
570 # are not mentioned are implicitly secret.
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
571 for phase in allphases[:-1]:
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
572 revset = "heads(%%ln & %s())" % phasenames[phase]
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
573 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
574 return headsbyphase
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
575
34321
4ef472b975ff bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents: 34320
diff changeset
576 def updatephases(repo, trgetter, headsbyphase):
33031
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
577 """Updates the repo with the given phase heads"""
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
578 # Now advance phase boundaries of all but secret phase
34321
4ef472b975ff bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents: 34320
diff changeset
579 #
4ef472b975ff bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents: 34320
diff changeset
580 # 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
581 # 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
582
33031
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
583 for phase in allphases[:-1]:
34321
4ef472b975ff bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents: 34320
diff changeset
584 revset = '%%ln - %s()' % phasenames[phase]
4ef472b975ff bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents: 34320
diff changeset
585 heads = [c.node() for c in repo.set(revset, headsbyphase[phase])]
4ef472b975ff bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents: 34320
diff changeset
586 if heads:
4ef472b975ff bundle2: only grab a transaction when 'phase-heads' affect the repository
Boris Feld <boris.feld@octobus.net>
parents: 34320
diff changeset
587 advanceboundary(repo, trgetter(), phase, heads)
33031
e8c8d81eb864 bundle: add config option to include phases
Martin von Zweigbergk <martinvonz@google.com>
parents: 32822
diff changeset
588
15649
ca7c4254a21a phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15648
diff changeset
589 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
590 """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
591
ca7c4254a21a phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15648
diff changeset
592 * 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
593 * 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
594
ca7c4254a21a phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15648
diff changeset
595 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
596 """
18002
9bc5873e52af clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17979
diff changeset
597 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
598 # 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
599 draftroots = []
15902
4252d9f08d7e phases: use nodemap to check for missing nodes
Sune Foldager <cryo@cyanite.org>
parents: 15892
diff changeset
600 nodemap = repo.changelog.nodemap # to filter unknown nodes
15649
ca7c4254a21a phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15648
diff changeset
601 for nhex, phase in roots.iteritems():
ca7c4254a21a phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15648
diff changeset
602 if nhex == 'publishing': # ignore data related to publish option
ca7c4254a21a phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15648
diff changeset
603 continue
ca7c4254a21a phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15648
diff changeset
604 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
605 phase = int(phase)
28174
f16b84b1e40e phases: use constants for phase values
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27874
diff changeset
606 if phase == public:
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15821
diff changeset
607 if node != nullid:
15953
52dc2b33d0be phase: fix warning text from invalid remote phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15948
diff changeset
608 repo.ui.warn(_('ignoring inconsistent public root'
52dc2b33d0be phase: fix warning text from invalid remote phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15948
diff changeset
609 ' from remote: %s\n') % nhex)
28174
f16b84b1e40e phases: use constants for phase values
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27874
diff changeset
610 elif phase == draft:
15902
4252d9f08d7e phases: use nodemap to check for missing nodes
Sune Foldager <cryo@cyanite.org>
parents: 15892
diff changeset
611 if node in nodemap:
15892
592b3d1742a1 phases: simplify phase exchange and movement over pushkey
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15821
diff changeset
612 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
613 else:
15953
52dc2b33d0be phase: fix warning text from invalid remote phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15948
diff changeset
614 repo.ui.warn(_('ignoring unexpected root from remote: %i %s\n')
52dc2b33d0be phase: fix warning text from invalid remote phase
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15948
diff changeset
615 % (phase, nhex))
15649
ca7c4254a21a phases: add a function to compute heads from root
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 15648
diff changeset
616 # compute heads
15954
b345f851d056 phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15953
diff changeset
617 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
618 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
619
34819
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
620 class remotephasessummary(object):
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
621 """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
622
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
623 :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
624 :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
625 :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
626 :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
627 """
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
628
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
629 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
630 unfi = repo.unfiltered()
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
631 self._allremoteroots = remoteroots
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
632
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
633 self.publishing = remoteroots.get('publishing', False)
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
634
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
635 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
636 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
637 # Get the list of all "heads" revs draft on remote
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
638 dheads = unfi.set('heads(%ln::%ln)', self.draftroots, remotesubset)
eb6375651974 phase: gather remote phase information in a summary object
Boris Feld <boris.feld@octobus.net>
parents: 34816
diff changeset
639 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
640
15954
b345f851d056 phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15953
diff changeset
641 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
642 """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
643
b345f851d056 phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15953
diff changeset
644 * `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
645 * `roots`: define the second we subtract from the first"""
18002
9bc5873e52af clfilter: phases logic should be unfiltered
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17979
diff changeset
646 repo = repo.unfiltered()
15954
b345f851d056 phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15953
diff changeset
647 revset = repo.set('heads((%ln + parents(%ln)) - (%ln::%ln))',
b345f851d056 phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15953
diff changeset
648 heads, roots, roots, heads)
b345f851d056 phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15953
diff changeset
649 return [c.node() for c in revset]
b345f851d056 phase: extracts heads computation logics from analyzeremotephases
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 15953
diff changeset
650
16030
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
651
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
652 def newcommitphase(ui):
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
653 """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
654
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
655 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
656
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
657 """
34563
1faa34347b24 configitems: update default value of 'phases.new-commit'
Boris Feld <boris.feld@octobus.net>
parents: 34321
diff changeset
658 v = ui.config('phases', 'new-commit')
16030
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
659 try:
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
660 return phasenames.index(v)
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
661 except ValueError:
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
662 try:
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
663 return int(v)
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
664 except ValueError:
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
665 msg = _("phases.new-commit: not a valid phase name ('%s')")
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
666 raise error.ConfigError(msg % v)
308406677e9d phases: allow phase name in phases.new-commit settings
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents: 16025
diff changeset
667
17671
fdd0fc046cf1 clfilter: introduce a `hassecret` function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17537
diff changeset
668 def hassecret(repo):
fdd0fc046cf1 clfilter: introduce a `hassecret` function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17537
diff changeset
669 """utility function that check if a repo have any secret changeset."""
fdd0fc046cf1 clfilter: introduce a `hassecret` function
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 17537
diff changeset
670 return bool(repo._phasecache.phaseroots[2])
34710
cdf833d7de98 phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents: 34563
diff changeset
671
cdf833d7de98 phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents: 34563
diff changeset
672 def preparehookargs(node, old, new):
cdf833d7de98 phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents: 34563
diff changeset
673 if old is None:
cdf833d7de98 phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents: 34563
diff changeset
674 old = ''
cdf833d7de98 phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents: 34563
diff changeset
675 else:
34876
eb1b964b354b phases: pass phase names to hooks instead of internal values
Kevin Bullock <kbullock+mercurial@ringworld.org>
parents: 34819
diff changeset
676 old = phasenames[old]
34710
cdf833d7de98 phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents: 34563
diff changeset
677 return {'node': node,
cdf833d7de98 phase: add a dedicated txnclose-phase hook
Boris Feld <boris.feld@octobus.net>
parents: 34563
diff changeset
678 'oldphase': old,
34876
eb1b964b354b phases: pass phase names to hooks instead of internal values
Kevin Bullock <kbullock+mercurial@ringworld.org>
parents: 34819
diff changeset
679 'phase': phasenames[new]}