##// END OF EJS Templates
debug-discovery: deal with case where common is empty...
marmoute -
r50299:c6aac500 stable
parent child Browse files
Show More
@@ -1,5056 +1,5058 b''
1 # debugcommands.py - command processing for debug* commands
1 # debugcommands.py - command processing for debug* commands
2 #
2 #
3 # Copyright 2005-2016 Olivia Mackall <olivia@selenic.com>
3 # Copyright 2005-2016 Olivia Mackall <olivia@selenic.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version.
6 # GNU General Public License version 2 or any later version.
7
7
8
8
9 import binascii
9 import binascii
10 import codecs
10 import codecs
11 import collections
11 import collections
12 import contextlib
12 import contextlib
13 import difflib
13 import difflib
14 import errno
14 import errno
15 import glob
15 import glob
16 import operator
16 import operator
17 import os
17 import os
18 import platform
18 import platform
19 import random
19 import random
20 import re
20 import re
21 import socket
21 import socket
22 import ssl
22 import ssl
23 import stat
23 import stat
24 import string
24 import string
25 import subprocess
25 import subprocess
26 import sys
26 import sys
27 import time
27 import time
28
28
29 from .i18n import _
29 from .i18n import _
30 from .node import (
30 from .node import (
31 bin,
31 bin,
32 hex,
32 hex,
33 nullrev,
33 nullrev,
34 short,
34 short,
35 )
35 )
36 from .pycompat import (
36 from .pycompat import (
37 getattr,
37 getattr,
38 open,
38 open,
39 )
39 )
40 from . import (
40 from . import (
41 bundle2,
41 bundle2,
42 bundlerepo,
42 bundlerepo,
43 changegroup,
43 changegroup,
44 cmdutil,
44 cmdutil,
45 color,
45 color,
46 context,
46 context,
47 copies,
47 copies,
48 dagparser,
48 dagparser,
49 dirstateutils,
49 dirstateutils,
50 encoding,
50 encoding,
51 error,
51 error,
52 exchange,
52 exchange,
53 extensions,
53 extensions,
54 filemerge,
54 filemerge,
55 filesetlang,
55 filesetlang,
56 formatter,
56 formatter,
57 hg,
57 hg,
58 httppeer,
58 httppeer,
59 localrepo,
59 localrepo,
60 lock as lockmod,
60 lock as lockmod,
61 logcmdutil,
61 logcmdutil,
62 mergestate as mergestatemod,
62 mergestate as mergestatemod,
63 metadata,
63 metadata,
64 obsolete,
64 obsolete,
65 obsutil,
65 obsutil,
66 pathutil,
66 pathutil,
67 phases,
67 phases,
68 policy,
68 policy,
69 pvec,
69 pvec,
70 pycompat,
70 pycompat,
71 registrar,
71 registrar,
72 repair,
72 repair,
73 repoview,
73 repoview,
74 requirements,
74 requirements,
75 revlog,
75 revlog,
76 revlogutils,
76 revlogutils,
77 revset,
77 revset,
78 revsetlang,
78 revsetlang,
79 scmutil,
79 scmutil,
80 setdiscovery,
80 setdiscovery,
81 simplemerge,
81 simplemerge,
82 sshpeer,
82 sshpeer,
83 sslutil,
83 sslutil,
84 streamclone,
84 streamclone,
85 strip,
85 strip,
86 tags as tagsmod,
86 tags as tagsmod,
87 templater,
87 templater,
88 treediscovery,
88 treediscovery,
89 upgrade,
89 upgrade,
90 url as urlmod,
90 url as urlmod,
91 util,
91 util,
92 vfs as vfsmod,
92 vfs as vfsmod,
93 wireprotoframing,
93 wireprotoframing,
94 wireprotoserver,
94 wireprotoserver,
95 )
95 )
96 from .interfaces import repository
96 from .interfaces import repository
97 from .utils import (
97 from .utils import (
98 cborutil,
98 cborutil,
99 compression,
99 compression,
100 dateutil,
100 dateutil,
101 procutil,
101 procutil,
102 stringutil,
102 stringutil,
103 urlutil,
103 urlutil,
104 )
104 )
105
105
106 from .revlogutils import (
106 from .revlogutils import (
107 constants as revlog_constants,
107 constants as revlog_constants,
108 debug as revlog_debug,
108 debug as revlog_debug,
109 deltas as deltautil,
109 deltas as deltautil,
110 nodemap,
110 nodemap,
111 rewrite,
111 rewrite,
112 sidedata,
112 sidedata,
113 )
113 )
114
114
115 release = lockmod.release
115 release = lockmod.release
116
116
117 table = {}
117 table = {}
118 table.update(strip.command._table)
118 table.update(strip.command._table)
119 command = registrar.command(table)
119 command = registrar.command(table)
120
120
121
121
122 @command(b'debugancestor', [], _(b'[INDEX] REV1 REV2'), optionalrepo=True)
122 @command(b'debugancestor', [], _(b'[INDEX] REV1 REV2'), optionalrepo=True)
123 def debugancestor(ui, repo, *args):
123 def debugancestor(ui, repo, *args):
124 """find the ancestor revision of two revisions in a given index"""
124 """find the ancestor revision of two revisions in a given index"""
125 if len(args) == 3:
125 if len(args) == 3:
126 index, rev1, rev2 = args
126 index, rev1, rev2 = args
127 r = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), index)
127 r = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), index)
128 lookup = r.lookup
128 lookup = r.lookup
129 elif len(args) == 2:
129 elif len(args) == 2:
130 if not repo:
130 if not repo:
131 raise error.Abort(
131 raise error.Abort(
132 _(b'there is no Mercurial repository here (.hg not found)')
132 _(b'there is no Mercurial repository here (.hg not found)')
133 )
133 )
134 rev1, rev2 = args
134 rev1, rev2 = args
135 r = repo.changelog
135 r = repo.changelog
136 lookup = repo.lookup
136 lookup = repo.lookup
137 else:
137 else:
138 raise error.Abort(_(b'either two or three arguments required'))
138 raise error.Abort(_(b'either two or three arguments required'))
139 a = r.ancestor(lookup(rev1), lookup(rev2))
139 a = r.ancestor(lookup(rev1), lookup(rev2))
140 ui.write(b'%d:%s\n' % (r.rev(a), hex(a)))
140 ui.write(b'%d:%s\n' % (r.rev(a), hex(a)))
141
141
142
142
143 @command(b'debugantivirusrunning', [])
143 @command(b'debugantivirusrunning', [])
144 def debugantivirusrunning(ui, repo):
144 def debugantivirusrunning(ui, repo):
145 """attempt to trigger an antivirus scanner to see if one is active"""
145 """attempt to trigger an antivirus scanner to see if one is active"""
146 with repo.cachevfs.open('eicar-test-file.com', b'wb') as f:
146 with repo.cachevfs.open('eicar-test-file.com', b'wb') as f:
147 f.write(
147 f.write(
148 util.b85decode(
148 util.b85decode(
149 # This is a base85-armored version of the EICAR test file. See
149 # This is a base85-armored version of the EICAR test file. See
150 # https://en.wikipedia.org/wiki/EICAR_test_file for details.
150 # https://en.wikipedia.org/wiki/EICAR_test_file for details.
151 b'ST#=}P$fV?P+K%yP+C|uG$>GBDK|qyDK~v2MM*<JQY}+dK~6+LQba95P'
151 b'ST#=}P$fV?P+K%yP+C|uG$>GBDK|qyDK~v2MM*<JQY}+dK~6+LQba95P'
152 b'E<)&Nm5l)EmTEQR4qnHOhq9iNGnJx'
152 b'E<)&Nm5l)EmTEQR4qnHOhq9iNGnJx'
153 )
153 )
154 )
154 )
155 # Give an AV engine time to scan the file.
155 # Give an AV engine time to scan the file.
156 time.sleep(2)
156 time.sleep(2)
157 util.unlink(repo.cachevfs.join('eicar-test-file.com'))
157 util.unlink(repo.cachevfs.join('eicar-test-file.com'))
158
158
159
159
160 @command(b'debugapplystreamclonebundle', [], b'FILE')
160 @command(b'debugapplystreamclonebundle', [], b'FILE')
161 def debugapplystreamclonebundle(ui, repo, fname):
161 def debugapplystreamclonebundle(ui, repo, fname):
162 """apply a stream clone bundle file"""
162 """apply a stream clone bundle file"""
163 f = hg.openpath(ui, fname)
163 f = hg.openpath(ui, fname)
164 gen = exchange.readbundle(ui, f, fname)
164 gen = exchange.readbundle(ui, f, fname)
165 gen.apply(repo)
165 gen.apply(repo)
166
166
167
167
168 @command(
168 @command(
169 b'debugbuilddag',
169 b'debugbuilddag',
170 [
170 [
171 (
171 (
172 b'm',
172 b'm',
173 b'mergeable-file',
173 b'mergeable-file',
174 None,
174 None,
175 _(b'add single file mergeable changes'),
175 _(b'add single file mergeable changes'),
176 ),
176 ),
177 (
177 (
178 b'o',
178 b'o',
179 b'overwritten-file',
179 b'overwritten-file',
180 None,
180 None,
181 _(b'add single file all revs overwrite'),
181 _(b'add single file all revs overwrite'),
182 ),
182 ),
183 (b'n', b'new-file', None, _(b'add new file at each rev')),
183 (b'n', b'new-file', None, _(b'add new file at each rev')),
184 (
184 (
185 b'',
185 b'',
186 b'from-existing',
186 b'from-existing',
187 None,
187 None,
188 _(b'continue from a non-empty repository'),
188 _(b'continue from a non-empty repository'),
189 ),
189 ),
190 ],
190 ],
191 _(b'[OPTION]... [TEXT]'),
191 _(b'[OPTION]... [TEXT]'),
192 )
192 )
193 def debugbuilddag(
193 def debugbuilddag(
194 ui,
194 ui,
195 repo,
195 repo,
196 text=None,
196 text=None,
197 mergeable_file=False,
197 mergeable_file=False,
198 overwritten_file=False,
198 overwritten_file=False,
199 new_file=False,
199 new_file=False,
200 from_existing=False,
200 from_existing=False,
201 ):
201 ):
202 """builds a repo with a given DAG from scratch in the current empty repo
202 """builds a repo with a given DAG from scratch in the current empty repo
203
203
204 The description of the DAG is read from stdin if not given on the
204 The description of the DAG is read from stdin if not given on the
205 command line.
205 command line.
206
206
207 Elements:
207 Elements:
208
208
209 - "+n" is a linear run of n nodes based on the current default parent
209 - "+n" is a linear run of n nodes based on the current default parent
210 - "." is a single node based on the current default parent
210 - "." is a single node based on the current default parent
211 - "$" resets the default parent to null (implied at the start);
211 - "$" resets the default parent to null (implied at the start);
212 otherwise the default parent is always the last node created
212 otherwise the default parent is always the last node created
213 - "<p" sets the default parent to the backref p
213 - "<p" sets the default parent to the backref p
214 - "*p" is a fork at parent p, which is a backref
214 - "*p" is a fork at parent p, which is a backref
215 - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
215 - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
216 - "/p2" is a merge of the preceding node and p2
216 - "/p2" is a merge of the preceding node and p2
217 - ":tag" defines a local tag for the preceding node
217 - ":tag" defines a local tag for the preceding node
218 - "@branch" sets the named branch for subsequent nodes
218 - "@branch" sets the named branch for subsequent nodes
219 - "#...\\n" is a comment up to the end of the line
219 - "#...\\n" is a comment up to the end of the line
220
220
221 Whitespace between the above elements is ignored.
221 Whitespace between the above elements is ignored.
222
222
223 A backref is either
223 A backref is either
224
224
225 - a number n, which references the node curr-n, where curr is the current
225 - a number n, which references the node curr-n, where curr is the current
226 node, or
226 node, or
227 - the name of a local tag you placed earlier using ":tag", or
227 - the name of a local tag you placed earlier using ":tag", or
228 - empty to denote the default parent.
228 - empty to denote the default parent.
229
229
230 All string valued-elements are either strictly alphanumeric, or must
230 All string valued-elements are either strictly alphanumeric, or must
231 be enclosed in double quotes ("..."), with "\\" as escape character.
231 be enclosed in double quotes ("..."), with "\\" as escape character.
232 """
232 """
233
233
234 if text is None:
234 if text is None:
235 ui.status(_(b"reading DAG from stdin\n"))
235 ui.status(_(b"reading DAG from stdin\n"))
236 text = ui.fin.read()
236 text = ui.fin.read()
237
237
238 cl = repo.changelog
238 cl = repo.changelog
239 if len(cl) > 0 and not from_existing:
239 if len(cl) > 0 and not from_existing:
240 raise error.Abort(_(b'repository is not empty'))
240 raise error.Abort(_(b'repository is not empty'))
241
241
242 # determine number of revs in DAG
242 # determine number of revs in DAG
243 total = 0
243 total = 0
244 for type, data in dagparser.parsedag(text):
244 for type, data in dagparser.parsedag(text):
245 if type == b'n':
245 if type == b'n':
246 total += 1
246 total += 1
247
247
248 if mergeable_file:
248 if mergeable_file:
249 linesperrev = 2
249 linesperrev = 2
250 # make a file with k lines per rev
250 # make a file with k lines per rev
251 initialmergedlines = [b'%d' % i for i in range(0, total * linesperrev)]
251 initialmergedlines = [b'%d' % i for i in range(0, total * linesperrev)]
252 initialmergedlines.append(b"")
252 initialmergedlines.append(b"")
253
253
254 tags = []
254 tags = []
255 progress = ui.makeprogress(
255 progress = ui.makeprogress(
256 _(b'building'), unit=_(b'revisions'), total=total
256 _(b'building'), unit=_(b'revisions'), total=total
257 )
257 )
258 with progress, repo.wlock(), repo.lock(), repo.transaction(b"builddag"):
258 with progress, repo.wlock(), repo.lock(), repo.transaction(b"builddag"):
259 at = -1
259 at = -1
260 atbranch = b'default'
260 atbranch = b'default'
261 nodeids = []
261 nodeids = []
262 id = 0
262 id = 0
263 progress.update(id)
263 progress.update(id)
264 for type, data in dagparser.parsedag(text):
264 for type, data in dagparser.parsedag(text):
265 if type == b'n':
265 if type == b'n':
266 ui.note((b'node %s\n' % pycompat.bytestr(data)))
266 ui.note((b'node %s\n' % pycompat.bytestr(data)))
267 id, ps = data
267 id, ps = data
268
268
269 files = []
269 files = []
270 filecontent = {}
270 filecontent = {}
271
271
272 p2 = None
272 p2 = None
273 if mergeable_file:
273 if mergeable_file:
274 fn = b"mf"
274 fn = b"mf"
275 p1 = repo[ps[0]]
275 p1 = repo[ps[0]]
276 if len(ps) > 1:
276 if len(ps) > 1:
277 p2 = repo[ps[1]]
277 p2 = repo[ps[1]]
278 pa = p1.ancestor(p2)
278 pa = p1.ancestor(p2)
279 base, local, other = [
279 base, local, other = [
280 x[fn].data() for x in (pa, p1, p2)
280 x[fn].data() for x in (pa, p1, p2)
281 ]
281 ]
282 m3 = simplemerge.Merge3Text(base, local, other)
282 m3 = simplemerge.Merge3Text(base, local, other)
283 ml = [
283 ml = [
284 l.strip()
284 l.strip()
285 for l in simplemerge.render_minimized(m3)[0]
285 for l in simplemerge.render_minimized(m3)[0]
286 ]
286 ]
287 ml.append(b"")
287 ml.append(b"")
288 elif at > 0:
288 elif at > 0:
289 ml = p1[fn].data().split(b"\n")
289 ml = p1[fn].data().split(b"\n")
290 else:
290 else:
291 ml = initialmergedlines
291 ml = initialmergedlines
292 ml[id * linesperrev] += b" r%i" % id
292 ml[id * linesperrev] += b" r%i" % id
293 mergedtext = b"\n".join(ml)
293 mergedtext = b"\n".join(ml)
294 files.append(fn)
294 files.append(fn)
295 filecontent[fn] = mergedtext
295 filecontent[fn] = mergedtext
296
296
297 if overwritten_file:
297 if overwritten_file:
298 fn = b"of"
298 fn = b"of"
299 files.append(fn)
299 files.append(fn)
300 filecontent[fn] = b"r%i\n" % id
300 filecontent[fn] = b"r%i\n" % id
301
301
302 if new_file:
302 if new_file:
303 fn = b"nf%i" % id
303 fn = b"nf%i" % id
304 files.append(fn)
304 files.append(fn)
305 filecontent[fn] = b"r%i\n" % id
305 filecontent[fn] = b"r%i\n" % id
306 if len(ps) > 1:
306 if len(ps) > 1:
307 if not p2:
307 if not p2:
308 p2 = repo[ps[1]]
308 p2 = repo[ps[1]]
309 for fn in p2:
309 for fn in p2:
310 if fn.startswith(b"nf"):
310 if fn.startswith(b"nf"):
311 files.append(fn)
311 files.append(fn)
312 filecontent[fn] = p2[fn].data()
312 filecontent[fn] = p2[fn].data()
313
313
314 def fctxfn(repo, cx, path):
314 def fctxfn(repo, cx, path):
315 if path in filecontent:
315 if path in filecontent:
316 return context.memfilectx(
316 return context.memfilectx(
317 repo, cx, path, filecontent[path]
317 repo, cx, path, filecontent[path]
318 )
318 )
319 return None
319 return None
320
320
321 if len(ps) == 0 or ps[0] < 0:
321 if len(ps) == 0 or ps[0] < 0:
322 pars = [None, None]
322 pars = [None, None]
323 elif len(ps) == 1:
323 elif len(ps) == 1:
324 pars = [nodeids[ps[0]], None]
324 pars = [nodeids[ps[0]], None]
325 else:
325 else:
326 pars = [nodeids[p] for p in ps]
326 pars = [nodeids[p] for p in ps]
327 cx = context.memctx(
327 cx = context.memctx(
328 repo,
328 repo,
329 pars,
329 pars,
330 b"r%i" % id,
330 b"r%i" % id,
331 files,
331 files,
332 fctxfn,
332 fctxfn,
333 date=(id, 0),
333 date=(id, 0),
334 user=b"debugbuilddag",
334 user=b"debugbuilddag",
335 extra={b'branch': atbranch},
335 extra={b'branch': atbranch},
336 )
336 )
337 nodeid = repo.commitctx(cx)
337 nodeid = repo.commitctx(cx)
338 nodeids.append(nodeid)
338 nodeids.append(nodeid)
339 at = id
339 at = id
340 elif type == b'l':
340 elif type == b'l':
341 id, name = data
341 id, name = data
342 ui.note((b'tag %s\n' % name))
342 ui.note((b'tag %s\n' % name))
343 tags.append(b"%s %s\n" % (hex(repo.changelog.node(id)), name))
343 tags.append(b"%s %s\n" % (hex(repo.changelog.node(id)), name))
344 elif type == b'a':
344 elif type == b'a':
345 ui.note((b'branch %s\n' % data))
345 ui.note((b'branch %s\n' % data))
346 atbranch = data
346 atbranch = data
347 progress.update(id)
347 progress.update(id)
348
348
349 if tags:
349 if tags:
350 repo.vfs.write(b"localtags", b"".join(tags))
350 repo.vfs.write(b"localtags", b"".join(tags))
351
351
352
352
353 def _debugchangegroup(ui, gen, all=None, indent=0, **opts):
353 def _debugchangegroup(ui, gen, all=None, indent=0, **opts):
354 indent_string = b' ' * indent
354 indent_string = b' ' * indent
355 if all:
355 if all:
356 ui.writenoi18n(
356 ui.writenoi18n(
357 b"%sformat: id, p1, p2, cset, delta base, len(delta)\n"
357 b"%sformat: id, p1, p2, cset, delta base, len(delta)\n"
358 % indent_string
358 % indent_string
359 )
359 )
360
360
361 def showchunks(named):
361 def showchunks(named):
362 ui.write(b"\n%s%s\n" % (indent_string, named))
362 ui.write(b"\n%s%s\n" % (indent_string, named))
363 for deltadata in gen.deltaiter():
363 for deltadata in gen.deltaiter():
364 node, p1, p2, cs, deltabase, delta, flags, sidedata = deltadata
364 node, p1, p2, cs, deltabase, delta, flags, sidedata = deltadata
365 ui.write(
365 ui.write(
366 b"%s%s %s %s %s %s %d\n"
366 b"%s%s %s %s %s %s %d\n"
367 % (
367 % (
368 indent_string,
368 indent_string,
369 hex(node),
369 hex(node),
370 hex(p1),
370 hex(p1),
371 hex(p2),
371 hex(p2),
372 hex(cs),
372 hex(cs),
373 hex(deltabase),
373 hex(deltabase),
374 len(delta),
374 len(delta),
375 )
375 )
376 )
376 )
377
377
378 gen.changelogheader()
378 gen.changelogheader()
379 showchunks(b"changelog")
379 showchunks(b"changelog")
380 gen.manifestheader()
380 gen.manifestheader()
381 showchunks(b"manifest")
381 showchunks(b"manifest")
382 for chunkdata in iter(gen.filelogheader, {}):
382 for chunkdata in iter(gen.filelogheader, {}):
383 fname = chunkdata[b'filename']
383 fname = chunkdata[b'filename']
384 showchunks(fname)
384 showchunks(fname)
385 else:
385 else:
386 if isinstance(gen, bundle2.unbundle20):
386 if isinstance(gen, bundle2.unbundle20):
387 raise error.Abort(_(b'use debugbundle2 for this file'))
387 raise error.Abort(_(b'use debugbundle2 for this file'))
388 gen.changelogheader()
388 gen.changelogheader()
389 for deltadata in gen.deltaiter():
389 for deltadata in gen.deltaiter():
390 node, p1, p2, cs, deltabase, delta, flags, sidedata = deltadata
390 node, p1, p2, cs, deltabase, delta, flags, sidedata = deltadata
391 ui.write(b"%s%s\n" % (indent_string, hex(node)))
391 ui.write(b"%s%s\n" % (indent_string, hex(node)))
392
392
393
393
394 def _debugobsmarkers(ui, part, indent=0, **opts):
394 def _debugobsmarkers(ui, part, indent=0, **opts):
395 """display version and markers contained in 'data'"""
395 """display version and markers contained in 'data'"""
396 opts = pycompat.byteskwargs(opts)
396 opts = pycompat.byteskwargs(opts)
397 data = part.read()
397 data = part.read()
398 indent_string = b' ' * indent
398 indent_string = b' ' * indent
399 try:
399 try:
400 version, markers = obsolete._readmarkers(data)
400 version, markers = obsolete._readmarkers(data)
401 except error.UnknownVersion as exc:
401 except error.UnknownVersion as exc:
402 msg = b"%sunsupported version: %s (%d bytes)\n"
402 msg = b"%sunsupported version: %s (%d bytes)\n"
403 msg %= indent_string, exc.version, len(data)
403 msg %= indent_string, exc.version, len(data)
404 ui.write(msg)
404 ui.write(msg)
405 else:
405 else:
406 msg = b"%sversion: %d (%d bytes)\n"
406 msg = b"%sversion: %d (%d bytes)\n"
407 msg %= indent_string, version, len(data)
407 msg %= indent_string, version, len(data)
408 ui.write(msg)
408 ui.write(msg)
409 fm = ui.formatter(b'debugobsolete', opts)
409 fm = ui.formatter(b'debugobsolete', opts)
410 for rawmarker in sorted(markers):
410 for rawmarker in sorted(markers):
411 m = obsutil.marker(None, rawmarker)
411 m = obsutil.marker(None, rawmarker)
412 fm.startitem()
412 fm.startitem()
413 fm.plain(indent_string)
413 fm.plain(indent_string)
414 cmdutil.showmarker(fm, m)
414 cmdutil.showmarker(fm, m)
415 fm.end()
415 fm.end()
416
416
417
417
418 def _debugphaseheads(ui, data, indent=0):
418 def _debugphaseheads(ui, data, indent=0):
419 """display version and markers contained in 'data'"""
419 """display version and markers contained in 'data'"""
420 indent_string = b' ' * indent
420 indent_string = b' ' * indent
421 headsbyphase = phases.binarydecode(data)
421 headsbyphase = phases.binarydecode(data)
422 for phase in phases.allphases:
422 for phase in phases.allphases:
423 for head in headsbyphase[phase]:
423 for head in headsbyphase[phase]:
424 ui.write(indent_string)
424 ui.write(indent_string)
425 ui.write(b'%s %s\n' % (hex(head), phases.phasenames[phase]))
425 ui.write(b'%s %s\n' % (hex(head), phases.phasenames[phase]))
426
426
427
427
428 def _quasirepr(thing):
428 def _quasirepr(thing):
429 if isinstance(thing, (dict, util.sortdict, collections.OrderedDict)):
429 if isinstance(thing, (dict, util.sortdict, collections.OrderedDict)):
430 return b'{%s}' % (
430 return b'{%s}' % (
431 b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing))
431 b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing))
432 )
432 )
433 return pycompat.bytestr(repr(thing))
433 return pycompat.bytestr(repr(thing))
434
434
435
435
436 def _debugbundle2(ui, gen, all=None, **opts):
436 def _debugbundle2(ui, gen, all=None, **opts):
437 """lists the contents of a bundle2"""
437 """lists the contents of a bundle2"""
438 if not isinstance(gen, bundle2.unbundle20):
438 if not isinstance(gen, bundle2.unbundle20):
439 raise error.Abort(_(b'not a bundle2 file'))
439 raise error.Abort(_(b'not a bundle2 file'))
440 ui.write((b'Stream params: %s\n' % _quasirepr(gen.params)))
440 ui.write((b'Stream params: %s\n' % _quasirepr(gen.params)))
441 parttypes = opts.get('part_type', [])
441 parttypes = opts.get('part_type', [])
442 for part in gen.iterparts():
442 for part in gen.iterparts():
443 if parttypes and part.type not in parttypes:
443 if parttypes and part.type not in parttypes:
444 continue
444 continue
445 msg = b'%s -- %s (mandatory: %r)\n'
445 msg = b'%s -- %s (mandatory: %r)\n'
446 ui.write((msg % (part.type, _quasirepr(part.params), part.mandatory)))
446 ui.write((msg % (part.type, _quasirepr(part.params), part.mandatory)))
447 if part.type == b'changegroup':
447 if part.type == b'changegroup':
448 version = part.params.get(b'version', b'01')
448 version = part.params.get(b'version', b'01')
449 cg = changegroup.getunbundler(version, part, b'UN')
449 cg = changegroup.getunbundler(version, part, b'UN')
450 if not ui.quiet:
450 if not ui.quiet:
451 _debugchangegroup(ui, cg, all=all, indent=4, **opts)
451 _debugchangegroup(ui, cg, all=all, indent=4, **opts)
452 if part.type == b'obsmarkers':
452 if part.type == b'obsmarkers':
453 if not ui.quiet:
453 if not ui.quiet:
454 _debugobsmarkers(ui, part, indent=4, **opts)
454 _debugobsmarkers(ui, part, indent=4, **opts)
455 if part.type == b'phase-heads':
455 if part.type == b'phase-heads':
456 if not ui.quiet:
456 if not ui.quiet:
457 _debugphaseheads(ui, part, indent=4)
457 _debugphaseheads(ui, part, indent=4)
458
458
459
459
460 @command(
460 @command(
461 b'debugbundle',
461 b'debugbundle',
462 [
462 [
463 (b'a', b'all', None, _(b'show all details')),
463 (b'a', b'all', None, _(b'show all details')),
464 (b'', b'part-type', [], _(b'show only the named part type')),
464 (b'', b'part-type', [], _(b'show only the named part type')),
465 (b'', b'spec', None, _(b'print the bundlespec of the bundle')),
465 (b'', b'spec', None, _(b'print the bundlespec of the bundle')),
466 ],
466 ],
467 _(b'FILE'),
467 _(b'FILE'),
468 norepo=True,
468 norepo=True,
469 )
469 )
470 def debugbundle(ui, bundlepath, all=None, spec=None, **opts):
470 def debugbundle(ui, bundlepath, all=None, spec=None, **opts):
471 """lists the contents of a bundle"""
471 """lists the contents of a bundle"""
472 with hg.openpath(ui, bundlepath) as f:
472 with hg.openpath(ui, bundlepath) as f:
473 if spec:
473 if spec:
474 spec = exchange.getbundlespec(ui, f)
474 spec = exchange.getbundlespec(ui, f)
475 ui.write(b'%s\n' % spec)
475 ui.write(b'%s\n' % spec)
476 return
476 return
477
477
478 gen = exchange.readbundle(ui, f, bundlepath)
478 gen = exchange.readbundle(ui, f, bundlepath)
479 if isinstance(gen, bundle2.unbundle20):
479 if isinstance(gen, bundle2.unbundle20):
480 return _debugbundle2(ui, gen, all=all, **opts)
480 return _debugbundle2(ui, gen, all=all, **opts)
481 _debugchangegroup(ui, gen, all=all, **opts)
481 _debugchangegroup(ui, gen, all=all, **opts)
482
482
483
483
484 @command(b'debugcapabilities', [], _(b'PATH'), norepo=True)
484 @command(b'debugcapabilities', [], _(b'PATH'), norepo=True)
485 def debugcapabilities(ui, path, **opts):
485 def debugcapabilities(ui, path, **opts):
486 """lists the capabilities of a remote peer"""
486 """lists the capabilities of a remote peer"""
487 opts = pycompat.byteskwargs(opts)
487 opts = pycompat.byteskwargs(opts)
488 peer = hg.peer(ui, opts, path)
488 peer = hg.peer(ui, opts, path)
489 try:
489 try:
490 caps = peer.capabilities()
490 caps = peer.capabilities()
491 ui.writenoi18n(b'Main capabilities:\n')
491 ui.writenoi18n(b'Main capabilities:\n')
492 for c in sorted(caps):
492 for c in sorted(caps):
493 ui.write(b' %s\n' % c)
493 ui.write(b' %s\n' % c)
494 b2caps = bundle2.bundle2caps(peer)
494 b2caps = bundle2.bundle2caps(peer)
495 if b2caps:
495 if b2caps:
496 ui.writenoi18n(b'Bundle2 capabilities:\n')
496 ui.writenoi18n(b'Bundle2 capabilities:\n')
497 for key, values in sorted(b2caps.items()):
497 for key, values in sorted(b2caps.items()):
498 ui.write(b' %s\n' % key)
498 ui.write(b' %s\n' % key)
499 for v in values:
499 for v in values:
500 ui.write(b' %s\n' % v)
500 ui.write(b' %s\n' % v)
501 finally:
501 finally:
502 peer.close()
502 peer.close()
503
503
504
504
505 @command(
505 @command(
506 b'debugchangedfiles',
506 b'debugchangedfiles',
507 [
507 [
508 (
508 (
509 b'',
509 b'',
510 b'compute',
510 b'compute',
511 False,
511 False,
512 b"compute information instead of reading it from storage",
512 b"compute information instead of reading it from storage",
513 ),
513 ),
514 ],
514 ],
515 b'REV',
515 b'REV',
516 )
516 )
517 def debugchangedfiles(ui, repo, rev, **opts):
517 def debugchangedfiles(ui, repo, rev, **opts):
518 """list the stored files changes for a revision"""
518 """list the stored files changes for a revision"""
519 ctx = logcmdutil.revsingle(repo, rev, None)
519 ctx = logcmdutil.revsingle(repo, rev, None)
520 files = None
520 files = None
521
521
522 if opts['compute']:
522 if opts['compute']:
523 files = metadata.compute_all_files_changes(ctx)
523 files = metadata.compute_all_files_changes(ctx)
524 else:
524 else:
525 sd = repo.changelog.sidedata(ctx.rev())
525 sd = repo.changelog.sidedata(ctx.rev())
526 files_block = sd.get(sidedata.SD_FILES)
526 files_block = sd.get(sidedata.SD_FILES)
527 if files_block is not None:
527 if files_block is not None:
528 files = metadata.decode_files_sidedata(sd)
528 files = metadata.decode_files_sidedata(sd)
529 if files is not None:
529 if files is not None:
530 for f in sorted(files.touched):
530 for f in sorted(files.touched):
531 if f in files.added:
531 if f in files.added:
532 action = b"added"
532 action = b"added"
533 elif f in files.removed:
533 elif f in files.removed:
534 action = b"removed"
534 action = b"removed"
535 elif f in files.merged:
535 elif f in files.merged:
536 action = b"merged"
536 action = b"merged"
537 elif f in files.salvaged:
537 elif f in files.salvaged:
538 action = b"salvaged"
538 action = b"salvaged"
539 else:
539 else:
540 action = b"touched"
540 action = b"touched"
541
541
542 copy_parent = b""
542 copy_parent = b""
543 copy_source = b""
543 copy_source = b""
544 if f in files.copied_from_p1:
544 if f in files.copied_from_p1:
545 copy_parent = b"p1"
545 copy_parent = b"p1"
546 copy_source = files.copied_from_p1[f]
546 copy_source = files.copied_from_p1[f]
547 elif f in files.copied_from_p2:
547 elif f in files.copied_from_p2:
548 copy_parent = b"p2"
548 copy_parent = b"p2"
549 copy_source = files.copied_from_p2[f]
549 copy_source = files.copied_from_p2[f]
550
550
551 data = (action, copy_parent, f, copy_source)
551 data = (action, copy_parent, f, copy_source)
552 template = b"%-8s %2s: %s, %s;\n"
552 template = b"%-8s %2s: %s, %s;\n"
553 ui.write(template % data)
553 ui.write(template % data)
554
554
555
555
556 @command(b'debugcheckstate', [], b'')
556 @command(b'debugcheckstate', [], b'')
557 def debugcheckstate(ui, repo):
557 def debugcheckstate(ui, repo):
558 """validate the correctness of the current dirstate"""
558 """validate the correctness of the current dirstate"""
559 parent1, parent2 = repo.dirstate.parents()
559 parent1, parent2 = repo.dirstate.parents()
560 m1 = repo[parent1].manifest()
560 m1 = repo[parent1].manifest()
561 m2 = repo[parent2].manifest()
561 m2 = repo[parent2].manifest()
562 errors = 0
562 errors = 0
563 for err in repo.dirstate.verify(m1, m2):
563 for err in repo.dirstate.verify(m1, m2):
564 ui.warn(err[0] % err[1:])
564 ui.warn(err[0] % err[1:])
565 errors += 1
565 errors += 1
566 if errors:
566 if errors:
567 errstr = _(b".hg/dirstate inconsistent with current parent's manifest")
567 errstr = _(b".hg/dirstate inconsistent with current parent's manifest")
568 raise error.Abort(errstr)
568 raise error.Abort(errstr)
569
569
570
570
571 @command(
571 @command(
572 b'debugcolor',
572 b'debugcolor',
573 [(b'', b'style', None, _(b'show all configured styles'))],
573 [(b'', b'style', None, _(b'show all configured styles'))],
574 b'hg debugcolor',
574 b'hg debugcolor',
575 )
575 )
576 def debugcolor(ui, repo, **opts):
576 def debugcolor(ui, repo, **opts):
577 """show available color, effects or style"""
577 """show available color, effects or style"""
578 ui.writenoi18n(b'color mode: %s\n' % stringutil.pprint(ui._colormode))
578 ui.writenoi18n(b'color mode: %s\n' % stringutil.pprint(ui._colormode))
579 if opts.get('style'):
579 if opts.get('style'):
580 return _debugdisplaystyle(ui)
580 return _debugdisplaystyle(ui)
581 else:
581 else:
582 return _debugdisplaycolor(ui)
582 return _debugdisplaycolor(ui)
583
583
584
584
585 def _debugdisplaycolor(ui):
585 def _debugdisplaycolor(ui):
586 ui = ui.copy()
586 ui = ui.copy()
587 ui._styles.clear()
587 ui._styles.clear()
588 for effect in color._activeeffects(ui).keys():
588 for effect in color._activeeffects(ui).keys():
589 ui._styles[effect] = effect
589 ui._styles[effect] = effect
590 if ui._terminfoparams:
590 if ui._terminfoparams:
591 for k, v in ui.configitems(b'color'):
591 for k, v in ui.configitems(b'color'):
592 if k.startswith(b'color.'):
592 if k.startswith(b'color.'):
593 ui._styles[k] = k[6:]
593 ui._styles[k] = k[6:]
594 elif k.startswith(b'terminfo.'):
594 elif k.startswith(b'terminfo.'):
595 ui._styles[k] = k[9:]
595 ui._styles[k] = k[9:]
596 ui.write(_(b'available colors:\n'))
596 ui.write(_(b'available colors:\n'))
597 # sort label with a '_' after the other to group '_background' entry.
597 # sort label with a '_' after the other to group '_background' entry.
598 items = sorted(ui._styles.items(), key=lambda i: (b'_' in i[0], i[0], i[1]))
598 items = sorted(ui._styles.items(), key=lambda i: (b'_' in i[0], i[0], i[1]))
599 for colorname, label in items:
599 for colorname, label in items:
600 ui.write(b'%s\n' % colorname, label=label)
600 ui.write(b'%s\n' % colorname, label=label)
601
601
602
602
603 def _debugdisplaystyle(ui):
603 def _debugdisplaystyle(ui):
604 ui.write(_(b'available style:\n'))
604 ui.write(_(b'available style:\n'))
605 if not ui._styles:
605 if not ui._styles:
606 return
606 return
607 width = max(len(s) for s in ui._styles)
607 width = max(len(s) for s in ui._styles)
608 for label, effects in sorted(ui._styles.items()):
608 for label, effects in sorted(ui._styles.items()):
609 ui.write(b'%s' % label, label=label)
609 ui.write(b'%s' % label, label=label)
610 if effects:
610 if effects:
611 # 50
611 # 50
612 ui.write(b': ')
612 ui.write(b': ')
613 ui.write(b' ' * (max(0, width - len(label))))
613 ui.write(b' ' * (max(0, width - len(label))))
614 ui.write(b', '.join(ui.label(e, e) for e in effects.split()))
614 ui.write(b', '.join(ui.label(e, e) for e in effects.split()))
615 ui.write(b'\n')
615 ui.write(b'\n')
616
616
617
617
618 @command(b'debugcreatestreamclonebundle', [], b'FILE')
618 @command(b'debugcreatestreamclonebundle', [], b'FILE')
619 def debugcreatestreamclonebundle(ui, repo, fname):
619 def debugcreatestreamclonebundle(ui, repo, fname):
620 """create a stream clone bundle file
620 """create a stream clone bundle file
621
621
622 Stream bundles are special bundles that are essentially archives of
622 Stream bundles are special bundles that are essentially archives of
623 revlog files. They are commonly used for cloning very quickly.
623 revlog files. They are commonly used for cloning very quickly.
624 """
624 """
625 # TODO we may want to turn this into an abort when this functionality
625 # TODO we may want to turn this into an abort when this functionality
626 # is moved into `hg bundle`.
626 # is moved into `hg bundle`.
627 if phases.hassecret(repo):
627 if phases.hassecret(repo):
628 ui.warn(
628 ui.warn(
629 _(
629 _(
630 b'(warning: stream clone bundle will contain secret '
630 b'(warning: stream clone bundle will contain secret '
631 b'revisions)\n'
631 b'revisions)\n'
632 )
632 )
633 )
633 )
634
634
635 requirements, gen = streamclone.generatebundlev1(repo)
635 requirements, gen = streamclone.generatebundlev1(repo)
636 changegroup.writechunks(ui, gen, fname)
636 changegroup.writechunks(ui, gen, fname)
637
637
638 ui.write(_(b'bundle requirements: %s\n') % b', '.join(sorted(requirements)))
638 ui.write(_(b'bundle requirements: %s\n') % b', '.join(sorted(requirements)))
639
639
640
640
641 @command(
641 @command(
642 b'debugdag',
642 b'debugdag',
643 [
643 [
644 (b't', b'tags', None, _(b'use tags as labels')),
644 (b't', b'tags', None, _(b'use tags as labels')),
645 (b'b', b'branches', None, _(b'annotate with branch names')),
645 (b'b', b'branches', None, _(b'annotate with branch names')),
646 (b'', b'dots', None, _(b'use dots for runs')),
646 (b'', b'dots', None, _(b'use dots for runs')),
647 (b's', b'spaces', None, _(b'separate elements by spaces')),
647 (b's', b'spaces', None, _(b'separate elements by spaces')),
648 ],
648 ],
649 _(b'[OPTION]... [FILE [REV]...]'),
649 _(b'[OPTION]... [FILE [REV]...]'),
650 optionalrepo=True,
650 optionalrepo=True,
651 )
651 )
652 def debugdag(ui, repo, file_=None, *revs, **opts):
652 def debugdag(ui, repo, file_=None, *revs, **opts):
653 """format the changelog or an index DAG as a concise textual description
653 """format the changelog or an index DAG as a concise textual description
654
654
655 If you pass a revlog index, the revlog's DAG is emitted. If you list
655 If you pass a revlog index, the revlog's DAG is emitted. If you list
656 revision numbers, they get labeled in the output as rN.
656 revision numbers, they get labeled in the output as rN.
657
657
658 Otherwise, the changelog DAG of the current repo is emitted.
658 Otherwise, the changelog DAG of the current repo is emitted.
659 """
659 """
660 spaces = opts.get('spaces')
660 spaces = opts.get('spaces')
661 dots = opts.get('dots')
661 dots = opts.get('dots')
662 if file_:
662 if file_:
663 rlog = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), file_)
663 rlog = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), file_)
664 revs = {int(r) for r in revs}
664 revs = {int(r) for r in revs}
665
665
666 def events():
666 def events():
667 for r in rlog:
667 for r in rlog:
668 yield b'n', (r, list(p for p in rlog.parentrevs(r) if p != -1))
668 yield b'n', (r, list(p for p in rlog.parentrevs(r) if p != -1))
669 if r in revs:
669 if r in revs:
670 yield b'l', (r, b"r%i" % r)
670 yield b'l', (r, b"r%i" % r)
671
671
672 elif repo:
672 elif repo:
673 cl = repo.changelog
673 cl = repo.changelog
674 tags = opts.get('tags')
674 tags = opts.get('tags')
675 branches = opts.get('branches')
675 branches = opts.get('branches')
676 if tags:
676 if tags:
677 labels = {}
677 labels = {}
678 for l, n in repo.tags().items():
678 for l, n in repo.tags().items():
679 labels.setdefault(cl.rev(n), []).append(l)
679 labels.setdefault(cl.rev(n), []).append(l)
680
680
681 def events():
681 def events():
682 b = b"default"
682 b = b"default"
683 for r in cl:
683 for r in cl:
684 if branches:
684 if branches:
685 newb = cl.read(cl.node(r))[5][b'branch']
685 newb = cl.read(cl.node(r))[5][b'branch']
686 if newb != b:
686 if newb != b:
687 yield b'a', newb
687 yield b'a', newb
688 b = newb
688 b = newb
689 yield b'n', (r, list(p for p in cl.parentrevs(r) if p != -1))
689 yield b'n', (r, list(p for p in cl.parentrevs(r) if p != -1))
690 if tags:
690 if tags:
691 ls = labels.get(r)
691 ls = labels.get(r)
692 if ls:
692 if ls:
693 for l in ls:
693 for l in ls:
694 yield b'l', (r, l)
694 yield b'l', (r, l)
695
695
696 else:
696 else:
697 raise error.Abort(_(b'need repo for changelog dag'))
697 raise error.Abort(_(b'need repo for changelog dag'))
698
698
699 for line in dagparser.dagtextlines(
699 for line in dagparser.dagtextlines(
700 events(),
700 events(),
701 addspaces=spaces,
701 addspaces=spaces,
702 wraplabels=True,
702 wraplabels=True,
703 wrapannotations=True,
703 wrapannotations=True,
704 wrapnonlinear=dots,
704 wrapnonlinear=dots,
705 usedots=dots,
705 usedots=dots,
706 maxlinewidth=70,
706 maxlinewidth=70,
707 ):
707 ):
708 ui.write(line)
708 ui.write(line)
709 ui.write(b"\n")
709 ui.write(b"\n")
710
710
711
711
712 @command(b'debugdata', cmdutil.debugrevlogopts, _(b'-c|-m|FILE REV'))
712 @command(b'debugdata', cmdutil.debugrevlogopts, _(b'-c|-m|FILE REV'))
713 def debugdata(ui, repo, file_, rev=None, **opts):
713 def debugdata(ui, repo, file_, rev=None, **opts):
714 """dump the contents of a data file revision"""
714 """dump the contents of a data file revision"""
715 opts = pycompat.byteskwargs(opts)
715 opts = pycompat.byteskwargs(opts)
716 if opts.get(b'changelog') or opts.get(b'manifest') or opts.get(b'dir'):
716 if opts.get(b'changelog') or opts.get(b'manifest') or opts.get(b'dir'):
717 if rev is not None:
717 if rev is not None:
718 raise error.CommandError(b'debugdata', _(b'invalid arguments'))
718 raise error.CommandError(b'debugdata', _(b'invalid arguments'))
719 file_, rev = None, file_
719 file_, rev = None, file_
720 elif rev is None:
720 elif rev is None:
721 raise error.CommandError(b'debugdata', _(b'invalid arguments'))
721 raise error.CommandError(b'debugdata', _(b'invalid arguments'))
722 r = cmdutil.openstorage(repo, b'debugdata', file_, opts)
722 r = cmdutil.openstorage(repo, b'debugdata', file_, opts)
723 try:
723 try:
724 ui.write(r.rawdata(r.lookup(rev)))
724 ui.write(r.rawdata(r.lookup(rev)))
725 except KeyError:
725 except KeyError:
726 raise error.Abort(_(b'invalid revision identifier %s') % rev)
726 raise error.Abort(_(b'invalid revision identifier %s') % rev)
727
727
728
728
729 @command(
729 @command(
730 b'debugdate',
730 b'debugdate',
731 [(b'e', b'extended', None, _(b'try extended date formats'))],
731 [(b'e', b'extended', None, _(b'try extended date formats'))],
732 _(b'[-e] DATE [RANGE]'),
732 _(b'[-e] DATE [RANGE]'),
733 norepo=True,
733 norepo=True,
734 optionalrepo=True,
734 optionalrepo=True,
735 )
735 )
736 def debugdate(ui, date, range=None, **opts):
736 def debugdate(ui, date, range=None, **opts):
737 """parse and display a date"""
737 """parse and display a date"""
738 if opts["extended"]:
738 if opts["extended"]:
739 d = dateutil.parsedate(date, dateutil.extendeddateformats)
739 d = dateutil.parsedate(date, dateutil.extendeddateformats)
740 else:
740 else:
741 d = dateutil.parsedate(date)
741 d = dateutil.parsedate(date)
742 ui.writenoi18n(b"internal: %d %d\n" % d)
742 ui.writenoi18n(b"internal: %d %d\n" % d)
743 ui.writenoi18n(b"standard: %s\n" % dateutil.datestr(d))
743 ui.writenoi18n(b"standard: %s\n" % dateutil.datestr(d))
744 if range:
744 if range:
745 m = dateutil.matchdate(range)
745 m = dateutil.matchdate(range)
746 ui.writenoi18n(b"match: %s\n" % m(d[0]))
746 ui.writenoi18n(b"match: %s\n" % m(d[0]))
747
747
748
748
749 @command(
749 @command(
750 b'debugdeltachain',
750 b'debugdeltachain',
751 cmdutil.debugrevlogopts + cmdutil.formatteropts,
751 cmdutil.debugrevlogopts + cmdutil.formatteropts,
752 _(b'-c|-m|FILE'),
752 _(b'-c|-m|FILE'),
753 optionalrepo=True,
753 optionalrepo=True,
754 )
754 )
755 def debugdeltachain(ui, repo, file_=None, **opts):
755 def debugdeltachain(ui, repo, file_=None, **opts):
756 """dump information about delta chains in a revlog
756 """dump information about delta chains in a revlog
757
757
758 Output can be templatized. Available template keywords are:
758 Output can be templatized. Available template keywords are:
759
759
760 :``rev``: revision number
760 :``rev``: revision number
761 :``p1``: parent 1 revision number (for reference)
761 :``p1``: parent 1 revision number (for reference)
762 :``p2``: parent 2 revision number (for reference)
762 :``p2``: parent 2 revision number (for reference)
763 :``chainid``: delta chain identifier (numbered by unique base)
763 :``chainid``: delta chain identifier (numbered by unique base)
764 :``chainlen``: delta chain length to this revision
764 :``chainlen``: delta chain length to this revision
765 :``prevrev``: previous revision in delta chain
765 :``prevrev``: previous revision in delta chain
766 :``deltatype``: role of delta / how it was computed
766 :``deltatype``: role of delta / how it was computed
767 - base: a full snapshot
767 - base: a full snapshot
768 - snap: an intermediate snapshot
768 - snap: an intermediate snapshot
769 - p1: a delta against the first parent
769 - p1: a delta against the first parent
770 - p2: a delta against the second parent
770 - p2: a delta against the second parent
771 - skip1: a delta against the same base as p1
771 - skip1: a delta against the same base as p1
772 (when p1 has empty delta
772 (when p1 has empty delta
773 - skip2: a delta against the same base as p2
773 - skip2: a delta against the same base as p2
774 (when p2 has empty delta
774 (when p2 has empty delta
775 - prev: a delta against the previous revision
775 - prev: a delta against the previous revision
776 - other: a delta against an arbitrary revision
776 - other: a delta against an arbitrary revision
777 :``compsize``: compressed size of revision
777 :``compsize``: compressed size of revision
778 :``uncompsize``: uncompressed size of revision
778 :``uncompsize``: uncompressed size of revision
779 :``chainsize``: total size of compressed revisions in chain
779 :``chainsize``: total size of compressed revisions in chain
780 :``chainratio``: total chain size divided by uncompressed revision size
780 :``chainratio``: total chain size divided by uncompressed revision size
781 (new delta chains typically start at ratio 2.00)
781 (new delta chains typically start at ratio 2.00)
782 :``lindist``: linear distance from base revision in delta chain to end
782 :``lindist``: linear distance from base revision in delta chain to end
783 of this revision
783 of this revision
784 :``extradist``: total size of revisions not part of this delta chain from
784 :``extradist``: total size of revisions not part of this delta chain from
785 base of delta chain to end of this revision; a measurement
785 base of delta chain to end of this revision; a measurement
786 of how much extra data we need to read/seek across to read
786 of how much extra data we need to read/seek across to read
787 the delta chain for this revision
787 the delta chain for this revision
788 :``extraratio``: extradist divided by chainsize; another representation of
788 :``extraratio``: extradist divided by chainsize; another representation of
789 how much unrelated data is needed to load this delta chain
789 how much unrelated data is needed to load this delta chain
790
790
791 If the repository is configured to use the sparse read, additional keywords
791 If the repository is configured to use the sparse read, additional keywords
792 are available:
792 are available:
793
793
794 :``readsize``: total size of data read from the disk for a revision
794 :``readsize``: total size of data read from the disk for a revision
795 (sum of the sizes of all the blocks)
795 (sum of the sizes of all the blocks)
796 :``largestblock``: size of the largest block of data read from the disk
796 :``largestblock``: size of the largest block of data read from the disk
797 :``readdensity``: density of useful bytes in the data read from the disk
797 :``readdensity``: density of useful bytes in the data read from the disk
798 :``srchunks``: in how many data hunks the whole revision would be read
798 :``srchunks``: in how many data hunks the whole revision would be read
799
799
800 The sparse read can be enabled with experimental.sparse-read = True
800 The sparse read can be enabled with experimental.sparse-read = True
801 """
801 """
802 opts = pycompat.byteskwargs(opts)
802 opts = pycompat.byteskwargs(opts)
803 r = cmdutil.openrevlog(repo, b'debugdeltachain', file_, opts)
803 r = cmdutil.openrevlog(repo, b'debugdeltachain', file_, opts)
804 index = r.index
804 index = r.index
805 start = r.start
805 start = r.start
806 length = r.length
806 length = r.length
807 generaldelta = r._generaldelta
807 generaldelta = r._generaldelta
808 withsparseread = getattr(r, '_withsparseread', False)
808 withsparseread = getattr(r, '_withsparseread', False)
809
809
810 # security to avoid crash on corrupted revlogs
810 # security to avoid crash on corrupted revlogs
811 total_revs = len(index)
811 total_revs = len(index)
812
812
813 def revinfo(rev):
813 def revinfo(rev):
814 e = index[rev]
814 e = index[rev]
815 compsize = e[revlog_constants.ENTRY_DATA_COMPRESSED_LENGTH]
815 compsize = e[revlog_constants.ENTRY_DATA_COMPRESSED_LENGTH]
816 uncompsize = e[revlog_constants.ENTRY_DATA_UNCOMPRESSED_LENGTH]
816 uncompsize = e[revlog_constants.ENTRY_DATA_UNCOMPRESSED_LENGTH]
817 chainsize = 0
817 chainsize = 0
818
818
819 base = e[revlog_constants.ENTRY_DELTA_BASE]
819 base = e[revlog_constants.ENTRY_DELTA_BASE]
820 p1 = e[revlog_constants.ENTRY_PARENT_1]
820 p1 = e[revlog_constants.ENTRY_PARENT_1]
821 p2 = e[revlog_constants.ENTRY_PARENT_2]
821 p2 = e[revlog_constants.ENTRY_PARENT_2]
822
822
823 # If the parents of a revision has an empty delta, we never try to delta
823 # If the parents of a revision has an empty delta, we never try to delta
824 # against that parent, but directly against the delta base of that
824 # against that parent, but directly against the delta base of that
825 # parent (recursively). It avoids adding a useless entry in the chain.
825 # parent (recursively). It avoids adding a useless entry in the chain.
826 #
826 #
827 # However we need to detect that as a special case for delta-type, that
827 # However we need to detect that as a special case for delta-type, that
828 # is not simply "other".
828 # is not simply "other".
829 p1_base = p1
829 p1_base = p1
830 if p1 != nullrev and p1 < total_revs:
830 if p1 != nullrev and p1 < total_revs:
831 e1 = index[p1]
831 e1 = index[p1]
832 while e1[revlog_constants.ENTRY_DATA_COMPRESSED_LENGTH] == 0:
832 while e1[revlog_constants.ENTRY_DATA_COMPRESSED_LENGTH] == 0:
833 new_base = e1[revlog_constants.ENTRY_DELTA_BASE]
833 new_base = e1[revlog_constants.ENTRY_DELTA_BASE]
834 if (
834 if (
835 new_base == p1_base
835 new_base == p1_base
836 or new_base == nullrev
836 or new_base == nullrev
837 or new_base >= total_revs
837 or new_base >= total_revs
838 ):
838 ):
839 break
839 break
840 p1_base = new_base
840 p1_base = new_base
841 e1 = index[p1_base]
841 e1 = index[p1_base]
842 p2_base = p2
842 p2_base = p2
843 if p2 != nullrev and p2 < total_revs:
843 if p2 != nullrev and p2 < total_revs:
844 e2 = index[p2]
844 e2 = index[p2]
845 while e2[revlog_constants.ENTRY_DATA_COMPRESSED_LENGTH] == 0:
845 while e2[revlog_constants.ENTRY_DATA_COMPRESSED_LENGTH] == 0:
846 new_base = e2[revlog_constants.ENTRY_DELTA_BASE]
846 new_base = e2[revlog_constants.ENTRY_DELTA_BASE]
847 if (
847 if (
848 new_base == p2_base
848 new_base == p2_base
849 or new_base == nullrev
849 or new_base == nullrev
850 or new_base >= total_revs
850 or new_base >= total_revs
851 ):
851 ):
852 break
852 break
853 p2_base = new_base
853 p2_base = new_base
854 e2 = index[p2_base]
854 e2 = index[p2_base]
855
855
856 if generaldelta:
856 if generaldelta:
857 if base == p1:
857 if base == p1:
858 deltatype = b'p1'
858 deltatype = b'p1'
859 elif base == p2:
859 elif base == p2:
860 deltatype = b'p2'
860 deltatype = b'p2'
861 elif base == rev:
861 elif base == rev:
862 deltatype = b'base'
862 deltatype = b'base'
863 elif base == p1_base:
863 elif base == p1_base:
864 deltatype = b'skip1'
864 deltatype = b'skip1'
865 elif base == p2_base:
865 elif base == p2_base:
866 deltatype = b'skip2'
866 deltatype = b'skip2'
867 elif r.issnapshot(rev):
867 elif r.issnapshot(rev):
868 deltatype = b'snap'
868 deltatype = b'snap'
869 elif base == rev - 1:
869 elif base == rev - 1:
870 deltatype = b'prev'
870 deltatype = b'prev'
871 else:
871 else:
872 deltatype = b'other'
872 deltatype = b'other'
873 else:
873 else:
874 if base == rev:
874 if base == rev:
875 deltatype = b'base'
875 deltatype = b'base'
876 else:
876 else:
877 deltatype = b'prev'
877 deltatype = b'prev'
878
878
879 chain = r._deltachain(rev)[0]
879 chain = r._deltachain(rev)[0]
880 for iterrev in chain:
880 for iterrev in chain:
881 e = index[iterrev]
881 e = index[iterrev]
882 chainsize += e[revlog_constants.ENTRY_DATA_COMPRESSED_LENGTH]
882 chainsize += e[revlog_constants.ENTRY_DATA_COMPRESSED_LENGTH]
883
883
884 return p1, p2, compsize, uncompsize, deltatype, chain, chainsize
884 return p1, p2, compsize, uncompsize, deltatype, chain, chainsize
885
885
886 fm = ui.formatter(b'debugdeltachain', opts)
886 fm = ui.formatter(b'debugdeltachain', opts)
887
887
888 fm.plain(
888 fm.plain(
889 b' rev p1 p2 chain# chainlen prev delta '
889 b' rev p1 p2 chain# chainlen prev delta '
890 b'size rawsize chainsize ratio lindist extradist '
890 b'size rawsize chainsize ratio lindist extradist '
891 b'extraratio'
891 b'extraratio'
892 )
892 )
893 if withsparseread:
893 if withsparseread:
894 fm.plain(b' readsize largestblk rddensity srchunks')
894 fm.plain(b' readsize largestblk rddensity srchunks')
895 fm.plain(b'\n')
895 fm.plain(b'\n')
896
896
897 chainbases = {}
897 chainbases = {}
898 for rev in r:
898 for rev in r:
899 p1, p2, comp, uncomp, deltatype, chain, chainsize = revinfo(rev)
899 p1, p2, comp, uncomp, deltatype, chain, chainsize = revinfo(rev)
900 chainbase = chain[0]
900 chainbase = chain[0]
901 chainid = chainbases.setdefault(chainbase, len(chainbases) + 1)
901 chainid = chainbases.setdefault(chainbase, len(chainbases) + 1)
902 basestart = start(chainbase)
902 basestart = start(chainbase)
903 revstart = start(rev)
903 revstart = start(rev)
904 lineardist = revstart + comp - basestart
904 lineardist = revstart + comp - basestart
905 extradist = lineardist - chainsize
905 extradist = lineardist - chainsize
906 try:
906 try:
907 prevrev = chain[-2]
907 prevrev = chain[-2]
908 except IndexError:
908 except IndexError:
909 prevrev = -1
909 prevrev = -1
910
910
911 if uncomp != 0:
911 if uncomp != 0:
912 chainratio = float(chainsize) / float(uncomp)
912 chainratio = float(chainsize) / float(uncomp)
913 else:
913 else:
914 chainratio = chainsize
914 chainratio = chainsize
915
915
916 if chainsize != 0:
916 if chainsize != 0:
917 extraratio = float(extradist) / float(chainsize)
917 extraratio = float(extradist) / float(chainsize)
918 else:
918 else:
919 extraratio = extradist
919 extraratio = extradist
920
920
921 fm.startitem()
921 fm.startitem()
922 fm.write(
922 fm.write(
923 b'rev p1 p2 chainid chainlen prevrev deltatype compsize '
923 b'rev p1 p2 chainid chainlen prevrev deltatype compsize '
924 b'uncompsize chainsize chainratio lindist extradist '
924 b'uncompsize chainsize chainratio lindist extradist '
925 b'extraratio',
925 b'extraratio',
926 b'%7d %7d %7d %7d %8d %8d %7s %10d %10d %10d %9.5f %9d %9d %10.5f',
926 b'%7d %7d %7d %7d %8d %8d %7s %10d %10d %10d %9.5f %9d %9d %10.5f',
927 rev,
927 rev,
928 p1,
928 p1,
929 p2,
929 p2,
930 chainid,
930 chainid,
931 len(chain),
931 len(chain),
932 prevrev,
932 prevrev,
933 deltatype,
933 deltatype,
934 comp,
934 comp,
935 uncomp,
935 uncomp,
936 chainsize,
936 chainsize,
937 chainratio,
937 chainratio,
938 lineardist,
938 lineardist,
939 extradist,
939 extradist,
940 extraratio,
940 extraratio,
941 rev=rev,
941 rev=rev,
942 chainid=chainid,
942 chainid=chainid,
943 chainlen=len(chain),
943 chainlen=len(chain),
944 prevrev=prevrev,
944 prevrev=prevrev,
945 deltatype=deltatype,
945 deltatype=deltatype,
946 compsize=comp,
946 compsize=comp,
947 uncompsize=uncomp,
947 uncompsize=uncomp,
948 chainsize=chainsize,
948 chainsize=chainsize,
949 chainratio=chainratio,
949 chainratio=chainratio,
950 lindist=lineardist,
950 lindist=lineardist,
951 extradist=extradist,
951 extradist=extradist,
952 extraratio=extraratio,
952 extraratio=extraratio,
953 )
953 )
954 if withsparseread:
954 if withsparseread:
955 readsize = 0
955 readsize = 0
956 largestblock = 0
956 largestblock = 0
957 srchunks = 0
957 srchunks = 0
958
958
959 for revschunk in deltautil.slicechunk(r, chain):
959 for revschunk in deltautil.slicechunk(r, chain):
960 srchunks += 1
960 srchunks += 1
961 blkend = start(revschunk[-1]) + length(revschunk[-1])
961 blkend = start(revschunk[-1]) + length(revschunk[-1])
962 blksize = blkend - start(revschunk[0])
962 blksize = blkend - start(revschunk[0])
963
963
964 readsize += blksize
964 readsize += blksize
965 if largestblock < blksize:
965 if largestblock < blksize:
966 largestblock = blksize
966 largestblock = blksize
967
967
968 if readsize:
968 if readsize:
969 readdensity = float(chainsize) / float(readsize)
969 readdensity = float(chainsize) / float(readsize)
970 else:
970 else:
971 readdensity = 1
971 readdensity = 1
972
972
973 fm.write(
973 fm.write(
974 b'readsize largestblock readdensity srchunks',
974 b'readsize largestblock readdensity srchunks',
975 b' %10d %10d %9.5f %8d',
975 b' %10d %10d %9.5f %8d',
976 readsize,
976 readsize,
977 largestblock,
977 largestblock,
978 readdensity,
978 readdensity,
979 srchunks,
979 srchunks,
980 readsize=readsize,
980 readsize=readsize,
981 largestblock=largestblock,
981 largestblock=largestblock,
982 readdensity=readdensity,
982 readdensity=readdensity,
983 srchunks=srchunks,
983 srchunks=srchunks,
984 )
984 )
985
985
986 fm.plain(b'\n')
986 fm.plain(b'\n')
987
987
988 fm.end()
988 fm.end()
989
989
990
990
991 @command(
991 @command(
992 b'debug-delta-find',
992 b'debug-delta-find',
993 cmdutil.debugrevlogopts + cmdutil.formatteropts,
993 cmdutil.debugrevlogopts + cmdutil.formatteropts,
994 _(b'-c|-m|FILE REV'),
994 _(b'-c|-m|FILE REV'),
995 optionalrepo=True,
995 optionalrepo=True,
996 )
996 )
997 def debugdeltafind(ui, repo, arg_1, arg_2=None, **opts):
997 def debugdeltafind(ui, repo, arg_1, arg_2=None, **opts):
998 """display the computation to get to a valid delta for storing REV
998 """display the computation to get to a valid delta for storing REV
999
999
1000 This command will replay the process used to find the "best" delta to store
1000 This command will replay the process used to find the "best" delta to store
1001 a revision and display information about all the steps used to get to that
1001 a revision and display information about all the steps used to get to that
1002 result.
1002 result.
1003
1003
1004 The revision use the revision number of the target storage (not changelog
1004 The revision use the revision number of the target storage (not changelog
1005 revision number).
1005 revision number).
1006
1006
1007 note: the process is initiated from a full text of the revision to store.
1007 note: the process is initiated from a full text of the revision to store.
1008 """
1008 """
1009 opts = pycompat.byteskwargs(opts)
1009 opts = pycompat.byteskwargs(opts)
1010 if arg_2 is None:
1010 if arg_2 is None:
1011 file_ = None
1011 file_ = None
1012 rev = arg_1
1012 rev = arg_1
1013 else:
1013 else:
1014 file_ = arg_1
1014 file_ = arg_1
1015 rev = arg_2
1015 rev = arg_2
1016
1016
1017 rev = int(rev)
1017 rev = int(rev)
1018
1018
1019 revlog = cmdutil.openrevlog(repo, b'debugdeltachain', file_, opts)
1019 revlog = cmdutil.openrevlog(repo, b'debugdeltachain', file_, opts)
1020
1020
1021 deltacomputer = deltautil.deltacomputer(
1021 deltacomputer = deltautil.deltacomputer(
1022 revlog,
1022 revlog,
1023 write_debug=ui.write,
1023 write_debug=ui.write,
1024 debug_search=True,
1024 debug_search=True,
1025 )
1025 )
1026
1026
1027 node = revlog.node(rev)
1027 node = revlog.node(rev)
1028 p1r, p2r = revlog.parentrevs(rev)
1028 p1r, p2r = revlog.parentrevs(rev)
1029 p1 = revlog.node(p1r)
1029 p1 = revlog.node(p1r)
1030 p2 = revlog.node(p2r)
1030 p2 = revlog.node(p2r)
1031 btext = [revlog.revision(rev)]
1031 btext = [revlog.revision(rev)]
1032 textlen = len(btext[0])
1032 textlen = len(btext[0])
1033 cachedelta = None
1033 cachedelta = None
1034 flags = revlog.flags(rev)
1034 flags = revlog.flags(rev)
1035
1035
1036 revinfo = revlogutils.revisioninfo(
1036 revinfo = revlogutils.revisioninfo(
1037 node,
1037 node,
1038 p1,
1038 p1,
1039 p2,
1039 p2,
1040 btext,
1040 btext,
1041 textlen,
1041 textlen,
1042 cachedelta,
1042 cachedelta,
1043 flags,
1043 flags,
1044 )
1044 )
1045
1045
1046 fh = revlog._datafp()
1046 fh = revlog._datafp()
1047 deltacomputer.finddeltainfo(revinfo, fh, target_rev=rev)
1047 deltacomputer.finddeltainfo(revinfo, fh, target_rev=rev)
1048
1048
1049
1049
1050 @command(
1050 @command(
1051 b'debugdirstate|debugstate',
1051 b'debugdirstate|debugstate',
1052 [
1052 [
1053 (
1053 (
1054 b'',
1054 b'',
1055 b'nodates',
1055 b'nodates',
1056 None,
1056 None,
1057 _(b'do not display the saved mtime (DEPRECATED)'),
1057 _(b'do not display the saved mtime (DEPRECATED)'),
1058 ),
1058 ),
1059 (b'', b'dates', True, _(b'display the saved mtime')),
1059 (b'', b'dates', True, _(b'display the saved mtime')),
1060 (b'', b'datesort', None, _(b'sort by saved mtime')),
1060 (b'', b'datesort', None, _(b'sort by saved mtime')),
1061 (
1061 (
1062 b'',
1062 b'',
1063 b'docket',
1063 b'docket',
1064 False,
1064 False,
1065 _(b'display the docket (metadata file) instead'),
1065 _(b'display the docket (metadata file) instead'),
1066 ),
1066 ),
1067 (
1067 (
1068 b'',
1068 b'',
1069 b'all',
1069 b'all',
1070 False,
1070 False,
1071 _(b'display dirstate-v2 tree nodes that would not exist in v1'),
1071 _(b'display dirstate-v2 tree nodes that would not exist in v1'),
1072 ),
1072 ),
1073 ],
1073 ],
1074 _(b'[OPTION]...'),
1074 _(b'[OPTION]...'),
1075 )
1075 )
1076 def debugstate(ui, repo, **opts):
1076 def debugstate(ui, repo, **opts):
1077 """show the contents of the current dirstate"""
1077 """show the contents of the current dirstate"""
1078
1078
1079 if opts.get("docket"):
1079 if opts.get("docket"):
1080 if not repo.dirstate._use_dirstate_v2:
1080 if not repo.dirstate._use_dirstate_v2:
1081 raise error.Abort(_(b'dirstate v1 does not have a docket'))
1081 raise error.Abort(_(b'dirstate v1 does not have a docket'))
1082
1082
1083 docket = repo.dirstate._map.docket
1083 docket = repo.dirstate._map.docket
1084 (
1084 (
1085 start_offset,
1085 start_offset,
1086 root_nodes,
1086 root_nodes,
1087 nodes_with_entry,
1087 nodes_with_entry,
1088 nodes_with_copy,
1088 nodes_with_copy,
1089 unused_bytes,
1089 unused_bytes,
1090 _unused,
1090 _unused,
1091 ignore_pattern,
1091 ignore_pattern,
1092 ) = dirstateutils.v2.TREE_METADATA.unpack(docket.tree_metadata)
1092 ) = dirstateutils.v2.TREE_METADATA.unpack(docket.tree_metadata)
1093
1093
1094 ui.write(_(b"size of dirstate data: %d\n") % docket.data_size)
1094 ui.write(_(b"size of dirstate data: %d\n") % docket.data_size)
1095 ui.write(_(b"data file uuid: %s\n") % docket.uuid)
1095 ui.write(_(b"data file uuid: %s\n") % docket.uuid)
1096 ui.write(_(b"start offset of root nodes: %d\n") % start_offset)
1096 ui.write(_(b"start offset of root nodes: %d\n") % start_offset)
1097 ui.write(_(b"number of root nodes: %d\n") % root_nodes)
1097 ui.write(_(b"number of root nodes: %d\n") % root_nodes)
1098 ui.write(_(b"nodes with entries: %d\n") % nodes_with_entry)
1098 ui.write(_(b"nodes with entries: %d\n") % nodes_with_entry)
1099 ui.write(_(b"nodes with copies: %d\n") % nodes_with_copy)
1099 ui.write(_(b"nodes with copies: %d\n") % nodes_with_copy)
1100 ui.write(_(b"number of unused bytes: %d\n") % unused_bytes)
1100 ui.write(_(b"number of unused bytes: %d\n") % unused_bytes)
1101 ui.write(
1101 ui.write(
1102 _(b"ignore pattern hash: %s\n") % binascii.hexlify(ignore_pattern)
1102 _(b"ignore pattern hash: %s\n") % binascii.hexlify(ignore_pattern)
1103 )
1103 )
1104 return
1104 return
1105
1105
1106 nodates = not opts['dates']
1106 nodates = not opts['dates']
1107 if opts.get('nodates') is not None:
1107 if opts.get('nodates') is not None:
1108 nodates = True
1108 nodates = True
1109 datesort = opts.get('datesort')
1109 datesort = opts.get('datesort')
1110
1110
1111 if datesort:
1111 if datesort:
1112
1112
1113 def keyfunc(entry):
1113 def keyfunc(entry):
1114 filename, _state, _mode, _size, mtime = entry
1114 filename, _state, _mode, _size, mtime = entry
1115 return (mtime, filename)
1115 return (mtime, filename)
1116
1116
1117 else:
1117 else:
1118 keyfunc = None # sort by filename
1118 keyfunc = None # sort by filename
1119 entries = list(repo.dirstate._map.debug_iter(all=opts['all']))
1119 entries = list(repo.dirstate._map.debug_iter(all=opts['all']))
1120 entries.sort(key=keyfunc)
1120 entries.sort(key=keyfunc)
1121 for entry in entries:
1121 for entry in entries:
1122 filename, state, mode, size, mtime = entry
1122 filename, state, mode, size, mtime = entry
1123 if mtime == -1:
1123 if mtime == -1:
1124 timestr = b'unset '
1124 timestr = b'unset '
1125 elif nodates:
1125 elif nodates:
1126 timestr = b'set '
1126 timestr = b'set '
1127 else:
1127 else:
1128 timestr = time.strftime("%Y-%m-%d %H:%M:%S ", time.localtime(mtime))
1128 timestr = time.strftime("%Y-%m-%d %H:%M:%S ", time.localtime(mtime))
1129 timestr = encoding.strtolocal(timestr)
1129 timestr = encoding.strtolocal(timestr)
1130 if mode & 0o20000:
1130 if mode & 0o20000:
1131 mode = b'lnk'
1131 mode = b'lnk'
1132 else:
1132 else:
1133 mode = b'%3o' % (mode & 0o777 & ~util.umask)
1133 mode = b'%3o' % (mode & 0o777 & ~util.umask)
1134 ui.write(b"%c %s %10d %s%s\n" % (state, mode, size, timestr, filename))
1134 ui.write(b"%c %s %10d %s%s\n" % (state, mode, size, timestr, filename))
1135 for f in repo.dirstate.copies():
1135 for f in repo.dirstate.copies():
1136 ui.write(_(b"copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
1136 ui.write(_(b"copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
1137
1137
1138
1138
1139 @command(
1139 @command(
1140 b'debugdirstateignorepatternshash',
1140 b'debugdirstateignorepatternshash',
1141 [],
1141 [],
1142 _(b''),
1142 _(b''),
1143 )
1143 )
1144 def debugdirstateignorepatternshash(ui, repo, **opts):
1144 def debugdirstateignorepatternshash(ui, repo, **opts):
1145 """show the hash of ignore patterns stored in dirstate if v2,
1145 """show the hash of ignore patterns stored in dirstate if v2,
1146 or nothing for dirstate-v2
1146 or nothing for dirstate-v2
1147 """
1147 """
1148 if repo.dirstate._use_dirstate_v2:
1148 if repo.dirstate._use_dirstate_v2:
1149 docket = repo.dirstate._map.docket
1149 docket = repo.dirstate._map.docket
1150 hash_len = 20 # 160 bits for SHA-1
1150 hash_len = 20 # 160 bits for SHA-1
1151 hash_bytes = docket.tree_metadata[-hash_len:]
1151 hash_bytes = docket.tree_metadata[-hash_len:]
1152 ui.write(binascii.hexlify(hash_bytes) + b'\n')
1152 ui.write(binascii.hexlify(hash_bytes) + b'\n')
1153
1153
1154
1154
1155 @command(
1155 @command(
1156 b'debugdiscovery',
1156 b'debugdiscovery',
1157 [
1157 [
1158 (b'', b'old', None, _(b'use old-style discovery')),
1158 (b'', b'old', None, _(b'use old-style discovery')),
1159 (
1159 (
1160 b'',
1160 b'',
1161 b'nonheads',
1161 b'nonheads',
1162 None,
1162 None,
1163 _(b'use old-style discovery with non-heads included'),
1163 _(b'use old-style discovery with non-heads included'),
1164 ),
1164 ),
1165 (b'', b'rev', [], b'restrict discovery to this set of revs'),
1165 (b'', b'rev', [], b'restrict discovery to this set of revs'),
1166 (b'', b'seed', b'12323', b'specify the random seed use for discovery'),
1166 (b'', b'seed', b'12323', b'specify the random seed use for discovery'),
1167 (
1167 (
1168 b'',
1168 b'',
1169 b'local-as-revs',
1169 b'local-as-revs',
1170 b"",
1170 b"",
1171 b'treat local has having these revisions only',
1171 b'treat local has having these revisions only',
1172 ),
1172 ),
1173 (
1173 (
1174 b'',
1174 b'',
1175 b'remote-as-revs',
1175 b'remote-as-revs',
1176 b"",
1176 b"",
1177 b'use local as remote, with only these revisions',
1177 b'use local as remote, with only these revisions',
1178 ),
1178 ),
1179 ]
1179 ]
1180 + cmdutil.remoteopts
1180 + cmdutil.remoteopts
1181 + cmdutil.formatteropts,
1181 + cmdutil.formatteropts,
1182 _(b'[--rev REV] [OTHER]'),
1182 _(b'[--rev REV] [OTHER]'),
1183 )
1183 )
1184 def debugdiscovery(ui, repo, remoteurl=b"default", **opts):
1184 def debugdiscovery(ui, repo, remoteurl=b"default", **opts):
1185 """runs the changeset discovery protocol in isolation
1185 """runs the changeset discovery protocol in isolation
1186
1186
1187 The local peer can be "replaced" by a subset of the local repository by
1187 The local peer can be "replaced" by a subset of the local repository by
1188 using the `--local-as-revs` flag. Int he same way, usual `remote` peer can
1188 using the `--local-as-revs` flag. Int he same way, usual `remote` peer can
1189 be "replaced" by a subset of the local repository using the
1189 be "replaced" by a subset of the local repository using the
1190 `--remote-as-revs` flag. This is useful to efficiently debug pathological
1190 `--remote-as-revs` flag. This is useful to efficiently debug pathological
1191 discovery situation.
1191 discovery situation.
1192
1192
1193 The following developer oriented config are relevant for people playing with this command:
1193 The following developer oriented config are relevant for people playing with this command:
1194
1194
1195 * devel.discovery.exchange-heads=True
1195 * devel.discovery.exchange-heads=True
1196
1196
1197 If False, the discovery will not start with
1197 If False, the discovery will not start with
1198 remote head fetching and local head querying.
1198 remote head fetching and local head querying.
1199
1199
1200 * devel.discovery.grow-sample=True
1200 * devel.discovery.grow-sample=True
1201
1201
1202 If False, the sample size used in set discovery will not be increased
1202 If False, the sample size used in set discovery will not be increased
1203 through the process
1203 through the process
1204
1204
1205 * devel.discovery.grow-sample.dynamic=True
1205 * devel.discovery.grow-sample.dynamic=True
1206
1206
1207 When discovery.grow-sample.dynamic is True, the default, the sample size is
1207 When discovery.grow-sample.dynamic is True, the default, the sample size is
1208 adapted to the shape of the undecided set (it is set to the max of:
1208 adapted to the shape of the undecided set (it is set to the max of:
1209 <target-size>, len(roots(undecided)), len(heads(undecided)
1209 <target-size>, len(roots(undecided)), len(heads(undecided)
1210
1210
1211 * devel.discovery.grow-sample.rate=1.05
1211 * devel.discovery.grow-sample.rate=1.05
1212
1212
1213 the rate at which the sample grow
1213 the rate at which the sample grow
1214
1214
1215 * devel.discovery.randomize=True
1215 * devel.discovery.randomize=True
1216
1216
1217 If andom sampling during discovery are deterministic. It is meant for
1217 If andom sampling during discovery are deterministic. It is meant for
1218 integration tests.
1218 integration tests.
1219
1219
1220 * devel.discovery.sample-size=200
1220 * devel.discovery.sample-size=200
1221
1221
1222 Control the initial size of the discovery sample
1222 Control the initial size of the discovery sample
1223
1223
1224 * devel.discovery.sample-size.initial=100
1224 * devel.discovery.sample-size.initial=100
1225
1225
1226 Control the initial size of the discovery for initial change
1226 Control the initial size of the discovery for initial change
1227 """
1227 """
1228 opts = pycompat.byteskwargs(opts)
1228 opts = pycompat.byteskwargs(opts)
1229 unfi = repo.unfiltered()
1229 unfi = repo.unfiltered()
1230
1230
1231 # setup potential extra filtering
1231 # setup potential extra filtering
1232 local_revs = opts[b"local_as_revs"]
1232 local_revs = opts[b"local_as_revs"]
1233 remote_revs = opts[b"remote_as_revs"]
1233 remote_revs = opts[b"remote_as_revs"]
1234
1234
1235 # make sure tests are repeatable
1235 # make sure tests are repeatable
1236 random.seed(int(opts[b'seed']))
1236 random.seed(int(opts[b'seed']))
1237
1237
1238 if not remote_revs:
1238 if not remote_revs:
1239
1239
1240 remoteurl, branches = urlutil.get_unique_pull_path(
1240 remoteurl, branches = urlutil.get_unique_pull_path(
1241 b'debugdiscovery', repo, ui, remoteurl
1241 b'debugdiscovery', repo, ui, remoteurl
1242 )
1242 )
1243 remote = hg.peer(repo, opts, remoteurl)
1243 remote = hg.peer(repo, opts, remoteurl)
1244 ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(remoteurl))
1244 ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(remoteurl))
1245 else:
1245 else:
1246 branches = (None, [])
1246 branches = (None, [])
1247 remote_filtered_revs = logcmdutil.revrange(
1247 remote_filtered_revs = logcmdutil.revrange(
1248 unfi, [b"not (::(%s))" % remote_revs]
1248 unfi, [b"not (::(%s))" % remote_revs]
1249 )
1249 )
1250 remote_filtered_revs = frozenset(remote_filtered_revs)
1250 remote_filtered_revs = frozenset(remote_filtered_revs)
1251
1251
1252 def remote_func(x):
1252 def remote_func(x):
1253 return remote_filtered_revs
1253 return remote_filtered_revs
1254
1254
1255 repoview.filtertable[b'debug-discovery-remote-filter'] = remote_func
1255 repoview.filtertable[b'debug-discovery-remote-filter'] = remote_func
1256
1256
1257 remote = repo.peer()
1257 remote = repo.peer()
1258 remote._repo = remote._repo.filtered(b'debug-discovery-remote-filter')
1258 remote._repo = remote._repo.filtered(b'debug-discovery-remote-filter')
1259
1259
1260 if local_revs:
1260 if local_revs:
1261 local_filtered_revs = logcmdutil.revrange(
1261 local_filtered_revs = logcmdutil.revrange(
1262 unfi, [b"not (::(%s))" % local_revs]
1262 unfi, [b"not (::(%s))" % local_revs]
1263 )
1263 )
1264 local_filtered_revs = frozenset(local_filtered_revs)
1264 local_filtered_revs = frozenset(local_filtered_revs)
1265
1265
1266 def local_func(x):
1266 def local_func(x):
1267 return local_filtered_revs
1267 return local_filtered_revs
1268
1268
1269 repoview.filtertable[b'debug-discovery-local-filter'] = local_func
1269 repoview.filtertable[b'debug-discovery-local-filter'] = local_func
1270 repo = repo.filtered(b'debug-discovery-local-filter')
1270 repo = repo.filtered(b'debug-discovery-local-filter')
1271
1271
1272 data = {}
1272 data = {}
1273 if opts.get(b'old'):
1273 if opts.get(b'old'):
1274
1274
1275 def doit(pushedrevs, remoteheads, remote=remote):
1275 def doit(pushedrevs, remoteheads, remote=remote):
1276 if not util.safehasattr(remote, b'branches'):
1276 if not util.safehasattr(remote, b'branches'):
1277 # enable in-client legacy support
1277 # enable in-client legacy support
1278 remote = localrepo.locallegacypeer(remote.local())
1278 remote = localrepo.locallegacypeer(remote.local())
1279 if remote_revs:
1279 if remote_revs:
1280 r = remote._repo.filtered(b'debug-discovery-remote-filter')
1280 r = remote._repo.filtered(b'debug-discovery-remote-filter')
1281 remote._repo = r
1281 remote._repo = r
1282 common, _in, hds = treediscovery.findcommonincoming(
1282 common, _in, hds = treediscovery.findcommonincoming(
1283 repo, remote, force=True, audit=data
1283 repo, remote, force=True, audit=data
1284 )
1284 )
1285 common = set(common)
1285 common = set(common)
1286 if not opts.get(b'nonheads'):
1286 if not opts.get(b'nonheads'):
1287 ui.writenoi18n(
1287 ui.writenoi18n(
1288 b"unpruned common: %s\n"
1288 b"unpruned common: %s\n"
1289 % b" ".join(sorted(short(n) for n in common))
1289 % b" ".join(sorted(short(n) for n in common))
1290 )
1290 )
1291
1291
1292 clnode = repo.changelog.node
1292 clnode = repo.changelog.node
1293 common = repo.revs(b'heads(::%ln)', common)
1293 common = repo.revs(b'heads(::%ln)', common)
1294 common = {clnode(r) for r in common}
1294 common = {clnode(r) for r in common}
1295 return common, hds
1295 return common, hds
1296
1296
1297 else:
1297 else:
1298
1298
1299 def doit(pushedrevs, remoteheads, remote=remote):
1299 def doit(pushedrevs, remoteheads, remote=remote):
1300 nodes = None
1300 nodes = None
1301 if pushedrevs:
1301 if pushedrevs:
1302 revs = logcmdutil.revrange(repo, pushedrevs)
1302 revs = logcmdutil.revrange(repo, pushedrevs)
1303 nodes = [repo[r].node() for r in revs]
1303 nodes = [repo[r].node() for r in revs]
1304 common, any, hds = setdiscovery.findcommonheads(
1304 common, any, hds = setdiscovery.findcommonheads(
1305 ui,
1305 ui,
1306 repo,
1306 repo,
1307 remote,
1307 remote,
1308 ancestorsof=nodes,
1308 ancestorsof=nodes,
1309 audit=data,
1309 audit=data,
1310 abortwhenunrelated=False,
1310 abortwhenunrelated=False,
1311 )
1311 )
1312 return common, hds
1312 return common, hds
1313
1313
1314 remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None)
1314 remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None)
1315 localrevs = opts[b'rev']
1315 localrevs = opts[b'rev']
1316
1316
1317 fm = ui.formatter(b'debugdiscovery', opts)
1317 fm = ui.formatter(b'debugdiscovery', opts)
1318 if fm.strict_format:
1318 if fm.strict_format:
1319
1319
1320 @contextlib.contextmanager
1320 @contextlib.contextmanager
1321 def may_capture_output():
1321 def may_capture_output():
1322 ui.pushbuffer()
1322 ui.pushbuffer()
1323 yield
1323 yield
1324 data[b'output'] = ui.popbuffer()
1324 data[b'output'] = ui.popbuffer()
1325
1325
1326 else:
1326 else:
1327 may_capture_output = util.nullcontextmanager
1327 may_capture_output = util.nullcontextmanager
1328 with may_capture_output():
1328 with may_capture_output():
1329 with util.timedcm('debug-discovery') as t:
1329 with util.timedcm('debug-discovery') as t:
1330 common, hds = doit(localrevs, remoterevs)
1330 common, hds = doit(localrevs, remoterevs)
1331
1331
1332 # compute all statistics
1332 # compute all statistics
1333 if len(common) == 1 and repo.nullid in common:
1334 common = set()
1333 heads_common = set(common)
1335 heads_common = set(common)
1334 heads_remote = set(hds)
1336 heads_remote = set(hds)
1335 heads_local = set(repo.heads())
1337 heads_local = set(repo.heads())
1336 # note: they cannot be a local or remote head that is in common and not
1338 # note: they cannot be a local or remote head that is in common and not
1337 # itself a head of common.
1339 # itself a head of common.
1338 heads_common_local = heads_common & heads_local
1340 heads_common_local = heads_common & heads_local
1339 heads_common_remote = heads_common & heads_remote
1341 heads_common_remote = heads_common & heads_remote
1340 heads_common_both = heads_common & heads_remote & heads_local
1342 heads_common_both = heads_common & heads_remote & heads_local
1341
1343
1342 all = repo.revs(b'all()')
1344 all = repo.revs(b'all()')
1343 common = repo.revs(b'::%ln', common)
1345 common = repo.revs(b'::%ln', common)
1344 roots_common = repo.revs(b'roots(::%ld)', common)
1346 roots_common = repo.revs(b'roots(::%ld)', common)
1345 missing = repo.revs(b'not ::%ld', common)
1347 missing = repo.revs(b'not ::%ld', common)
1346 heads_missing = repo.revs(b'heads(%ld)', missing)
1348 heads_missing = repo.revs(b'heads(%ld)', missing)
1347 roots_missing = repo.revs(b'roots(%ld)', missing)
1349 roots_missing = repo.revs(b'roots(%ld)', missing)
1348 assert len(common) + len(missing) == len(all)
1350 assert len(common) + len(missing) == len(all)
1349
1351
1350 initial_undecided = repo.revs(
1352 initial_undecided = repo.revs(
1351 b'not (::%ln or %ln::)', heads_common_remote, heads_common_local
1353 b'not (::%ln or %ln::)', heads_common_remote, heads_common_local
1352 )
1354 )
1353 heads_initial_undecided = repo.revs(b'heads(%ld)', initial_undecided)
1355 heads_initial_undecided = repo.revs(b'heads(%ld)', initial_undecided)
1354 roots_initial_undecided = repo.revs(b'roots(%ld)', initial_undecided)
1356 roots_initial_undecided = repo.revs(b'roots(%ld)', initial_undecided)
1355 common_initial_undecided = initial_undecided & common
1357 common_initial_undecided = initial_undecided & common
1356 missing_initial_undecided = initial_undecided & missing
1358 missing_initial_undecided = initial_undecided & missing
1357
1359
1358 data[b'elapsed'] = t.elapsed
1360 data[b'elapsed'] = t.elapsed
1359 data[b'nb-common-heads'] = len(heads_common)
1361 data[b'nb-common-heads'] = len(heads_common)
1360 data[b'nb-common-heads-local'] = len(heads_common_local)
1362 data[b'nb-common-heads-local'] = len(heads_common_local)
1361 data[b'nb-common-heads-remote'] = len(heads_common_remote)
1363 data[b'nb-common-heads-remote'] = len(heads_common_remote)
1362 data[b'nb-common-heads-both'] = len(heads_common_both)
1364 data[b'nb-common-heads-both'] = len(heads_common_both)
1363 data[b'nb-common-roots'] = len(roots_common)
1365 data[b'nb-common-roots'] = len(roots_common)
1364 data[b'nb-head-local'] = len(heads_local)
1366 data[b'nb-head-local'] = len(heads_local)
1365 data[b'nb-head-local-missing'] = len(heads_local) - len(heads_common_local)
1367 data[b'nb-head-local-missing'] = len(heads_local) - len(heads_common_local)
1366 data[b'nb-head-remote'] = len(heads_remote)
1368 data[b'nb-head-remote'] = len(heads_remote)
1367 data[b'nb-head-remote-unknown'] = len(heads_remote) - len(
1369 data[b'nb-head-remote-unknown'] = len(heads_remote) - len(
1368 heads_common_remote
1370 heads_common_remote
1369 )
1371 )
1370 data[b'nb-revs'] = len(all)
1372 data[b'nb-revs'] = len(all)
1371 data[b'nb-revs-common'] = len(common)
1373 data[b'nb-revs-common'] = len(common)
1372 data[b'nb-revs-missing'] = len(missing)
1374 data[b'nb-revs-missing'] = len(missing)
1373 data[b'nb-missing-heads'] = len(heads_missing)
1375 data[b'nb-missing-heads'] = len(heads_missing)
1374 data[b'nb-missing-roots'] = len(roots_missing)
1376 data[b'nb-missing-roots'] = len(roots_missing)
1375 data[b'nb-ini_und'] = len(initial_undecided)
1377 data[b'nb-ini_und'] = len(initial_undecided)
1376 data[b'nb-ini_und-heads'] = len(heads_initial_undecided)
1378 data[b'nb-ini_und-heads'] = len(heads_initial_undecided)
1377 data[b'nb-ini_und-roots'] = len(roots_initial_undecided)
1379 data[b'nb-ini_und-roots'] = len(roots_initial_undecided)
1378 data[b'nb-ini_und-common'] = len(common_initial_undecided)
1380 data[b'nb-ini_und-common'] = len(common_initial_undecided)
1379 data[b'nb-ini_und-missing'] = len(missing_initial_undecided)
1381 data[b'nb-ini_und-missing'] = len(missing_initial_undecided)
1380
1382
1381 fm.startitem()
1383 fm.startitem()
1382 fm.data(**pycompat.strkwargs(data))
1384 fm.data(**pycompat.strkwargs(data))
1383 # display discovery summary
1385 # display discovery summary
1384 fm.plain(b"elapsed time: %(elapsed)f seconds\n" % data)
1386 fm.plain(b"elapsed time: %(elapsed)f seconds\n" % data)
1385 fm.plain(b"round-trips: %(total-roundtrips)9d\n" % data)
1387 fm.plain(b"round-trips: %(total-roundtrips)9d\n" % data)
1386 if b'total-round-trips-heads' in data:
1388 if b'total-round-trips-heads' in data:
1387 fm.plain(
1389 fm.plain(
1388 b" round-trips-heads: %(total-round-trips-heads)9d\n" % data
1390 b" round-trips-heads: %(total-round-trips-heads)9d\n" % data
1389 )
1391 )
1390 if b'total-round-trips-branches' in data:
1392 if b'total-round-trips-branches' in data:
1391 fm.plain(
1393 fm.plain(
1392 b" round-trips-branches: %(total-round-trips-branches)9d\n"
1394 b" round-trips-branches: %(total-round-trips-branches)9d\n"
1393 % data
1395 % data
1394 )
1396 )
1395 if b'total-round-trips-between' in data:
1397 if b'total-round-trips-between' in data:
1396 fm.plain(
1398 fm.plain(
1397 b" round-trips-between: %(total-round-trips-between)9d\n" % data
1399 b" round-trips-between: %(total-round-trips-between)9d\n" % data
1398 )
1400 )
1399 fm.plain(b"queries: %(total-queries)9d\n" % data)
1401 fm.plain(b"queries: %(total-queries)9d\n" % data)
1400 if b'total-queries-branches' in data:
1402 if b'total-queries-branches' in data:
1401 fm.plain(b" queries-branches: %(total-queries-branches)9d\n" % data)
1403 fm.plain(b" queries-branches: %(total-queries-branches)9d\n" % data)
1402 if b'total-queries-between' in data:
1404 if b'total-queries-between' in data:
1403 fm.plain(b" queries-between: %(total-queries-between)9d\n" % data)
1405 fm.plain(b" queries-between: %(total-queries-between)9d\n" % data)
1404 fm.plain(b"heads summary:\n")
1406 fm.plain(b"heads summary:\n")
1405 fm.plain(b" total common heads: %(nb-common-heads)9d\n" % data)
1407 fm.plain(b" total common heads: %(nb-common-heads)9d\n" % data)
1406 fm.plain(b" also local heads: %(nb-common-heads-local)9d\n" % data)
1408 fm.plain(b" also local heads: %(nb-common-heads-local)9d\n" % data)
1407 fm.plain(b" also remote heads: %(nb-common-heads-remote)9d\n" % data)
1409 fm.plain(b" also remote heads: %(nb-common-heads-remote)9d\n" % data)
1408 fm.plain(b" both: %(nb-common-heads-both)9d\n" % data)
1410 fm.plain(b" both: %(nb-common-heads-both)9d\n" % data)
1409 fm.plain(b" local heads: %(nb-head-local)9d\n" % data)
1411 fm.plain(b" local heads: %(nb-head-local)9d\n" % data)
1410 fm.plain(b" common: %(nb-common-heads-local)9d\n" % data)
1412 fm.plain(b" common: %(nb-common-heads-local)9d\n" % data)
1411 fm.plain(b" missing: %(nb-head-local-missing)9d\n" % data)
1413 fm.plain(b" missing: %(nb-head-local-missing)9d\n" % data)
1412 fm.plain(b" remote heads: %(nb-head-remote)9d\n" % data)
1414 fm.plain(b" remote heads: %(nb-head-remote)9d\n" % data)
1413 fm.plain(b" common: %(nb-common-heads-remote)9d\n" % data)
1415 fm.plain(b" common: %(nb-common-heads-remote)9d\n" % data)
1414 fm.plain(b" unknown: %(nb-head-remote-unknown)9d\n" % data)
1416 fm.plain(b" unknown: %(nb-head-remote-unknown)9d\n" % data)
1415 fm.plain(b"local changesets: %(nb-revs)9d\n" % data)
1417 fm.plain(b"local changesets: %(nb-revs)9d\n" % data)
1416 fm.plain(b" common: %(nb-revs-common)9d\n" % data)
1418 fm.plain(b" common: %(nb-revs-common)9d\n" % data)
1417 fm.plain(b" heads: %(nb-common-heads)9d\n" % data)
1419 fm.plain(b" heads: %(nb-common-heads)9d\n" % data)
1418 fm.plain(b" roots: %(nb-common-roots)9d\n" % data)
1420 fm.plain(b" roots: %(nb-common-roots)9d\n" % data)
1419 fm.plain(b" missing: %(nb-revs-missing)9d\n" % data)
1421 fm.plain(b" missing: %(nb-revs-missing)9d\n" % data)
1420 fm.plain(b" heads: %(nb-missing-heads)9d\n" % data)
1422 fm.plain(b" heads: %(nb-missing-heads)9d\n" % data)
1421 fm.plain(b" roots: %(nb-missing-roots)9d\n" % data)
1423 fm.plain(b" roots: %(nb-missing-roots)9d\n" % data)
1422 fm.plain(b" first undecided set: %(nb-ini_und)9d\n" % data)
1424 fm.plain(b" first undecided set: %(nb-ini_und)9d\n" % data)
1423 fm.plain(b" heads: %(nb-ini_und-heads)9d\n" % data)
1425 fm.plain(b" heads: %(nb-ini_und-heads)9d\n" % data)
1424 fm.plain(b" roots: %(nb-ini_und-roots)9d\n" % data)
1426 fm.plain(b" roots: %(nb-ini_und-roots)9d\n" % data)
1425 fm.plain(b" common: %(nb-ini_und-common)9d\n" % data)
1427 fm.plain(b" common: %(nb-ini_und-common)9d\n" % data)
1426 fm.plain(b" missing: %(nb-ini_und-missing)9d\n" % data)
1428 fm.plain(b" missing: %(nb-ini_und-missing)9d\n" % data)
1427
1429
1428 if ui.verbose:
1430 if ui.verbose:
1429 fm.plain(
1431 fm.plain(
1430 b"common heads: %s\n"
1432 b"common heads: %s\n"
1431 % b" ".join(sorted(short(n) for n in heads_common))
1433 % b" ".join(sorted(short(n) for n in heads_common))
1432 )
1434 )
1433 fm.end()
1435 fm.end()
1434
1436
1435
1437
1436 _chunksize = 4 << 10
1438 _chunksize = 4 << 10
1437
1439
1438
1440
1439 @command(
1441 @command(
1440 b'debugdownload',
1442 b'debugdownload',
1441 [
1443 [
1442 (b'o', b'output', b'', _(b'path')),
1444 (b'o', b'output', b'', _(b'path')),
1443 ],
1445 ],
1444 optionalrepo=True,
1446 optionalrepo=True,
1445 )
1447 )
1446 def debugdownload(ui, repo, url, output=None, **opts):
1448 def debugdownload(ui, repo, url, output=None, **opts):
1447 """download a resource using Mercurial logic and config"""
1449 """download a resource using Mercurial logic and config"""
1448 fh = urlmod.open(ui, url, output)
1450 fh = urlmod.open(ui, url, output)
1449
1451
1450 dest = ui
1452 dest = ui
1451 if output:
1453 if output:
1452 dest = open(output, b"wb", _chunksize)
1454 dest = open(output, b"wb", _chunksize)
1453 try:
1455 try:
1454 data = fh.read(_chunksize)
1456 data = fh.read(_chunksize)
1455 while data:
1457 while data:
1456 dest.write(data)
1458 dest.write(data)
1457 data = fh.read(_chunksize)
1459 data = fh.read(_chunksize)
1458 finally:
1460 finally:
1459 if output:
1461 if output:
1460 dest.close()
1462 dest.close()
1461
1463
1462
1464
1463 @command(b'debugextensions', cmdutil.formatteropts, [], optionalrepo=True)
1465 @command(b'debugextensions', cmdutil.formatteropts, [], optionalrepo=True)
1464 def debugextensions(ui, repo, **opts):
1466 def debugextensions(ui, repo, **opts):
1465 '''show information about active extensions'''
1467 '''show information about active extensions'''
1466 opts = pycompat.byteskwargs(opts)
1468 opts = pycompat.byteskwargs(opts)
1467 exts = extensions.extensions(ui)
1469 exts = extensions.extensions(ui)
1468 hgver = util.version()
1470 hgver = util.version()
1469 fm = ui.formatter(b'debugextensions', opts)
1471 fm = ui.formatter(b'debugextensions', opts)
1470 for extname, extmod in sorted(exts, key=operator.itemgetter(0)):
1472 for extname, extmod in sorted(exts, key=operator.itemgetter(0)):
1471 isinternal = extensions.ismoduleinternal(extmod)
1473 isinternal = extensions.ismoduleinternal(extmod)
1472 extsource = None
1474 extsource = None
1473
1475
1474 if util.safehasattr(extmod, '__file__'):
1476 if util.safehasattr(extmod, '__file__'):
1475 extsource = pycompat.fsencode(extmod.__file__)
1477 extsource = pycompat.fsencode(extmod.__file__)
1476 elif getattr(sys, 'oxidized', False):
1478 elif getattr(sys, 'oxidized', False):
1477 extsource = pycompat.sysexecutable
1479 extsource = pycompat.sysexecutable
1478 if isinternal:
1480 if isinternal:
1479 exttestedwith = [] # never expose magic string to users
1481 exttestedwith = [] # never expose magic string to users
1480 else:
1482 else:
1481 exttestedwith = getattr(extmod, 'testedwith', b'').split()
1483 exttestedwith = getattr(extmod, 'testedwith', b'').split()
1482 extbuglink = getattr(extmod, 'buglink', None)
1484 extbuglink = getattr(extmod, 'buglink', None)
1483
1485
1484 fm.startitem()
1486 fm.startitem()
1485
1487
1486 if ui.quiet or ui.verbose:
1488 if ui.quiet or ui.verbose:
1487 fm.write(b'name', b'%s\n', extname)
1489 fm.write(b'name', b'%s\n', extname)
1488 else:
1490 else:
1489 fm.write(b'name', b'%s', extname)
1491 fm.write(b'name', b'%s', extname)
1490 if isinternal or hgver in exttestedwith:
1492 if isinternal or hgver in exttestedwith:
1491 fm.plain(b'\n')
1493 fm.plain(b'\n')
1492 elif not exttestedwith:
1494 elif not exttestedwith:
1493 fm.plain(_(b' (untested!)\n'))
1495 fm.plain(_(b' (untested!)\n'))
1494 else:
1496 else:
1495 lasttestedversion = exttestedwith[-1]
1497 lasttestedversion = exttestedwith[-1]
1496 fm.plain(b' (%s!)\n' % lasttestedversion)
1498 fm.plain(b' (%s!)\n' % lasttestedversion)
1497
1499
1498 fm.condwrite(
1500 fm.condwrite(
1499 ui.verbose and extsource,
1501 ui.verbose and extsource,
1500 b'source',
1502 b'source',
1501 _(b' location: %s\n'),
1503 _(b' location: %s\n'),
1502 extsource or b"",
1504 extsource or b"",
1503 )
1505 )
1504
1506
1505 if ui.verbose:
1507 if ui.verbose:
1506 fm.plain(_(b' bundled: %s\n') % [b'no', b'yes'][isinternal])
1508 fm.plain(_(b' bundled: %s\n') % [b'no', b'yes'][isinternal])
1507 fm.data(bundled=isinternal)
1509 fm.data(bundled=isinternal)
1508
1510
1509 fm.condwrite(
1511 fm.condwrite(
1510 ui.verbose and exttestedwith,
1512 ui.verbose and exttestedwith,
1511 b'testedwith',
1513 b'testedwith',
1512 _(b' tested with: %s\n'),
1514 _(b' tested with: %s\n'),
1513 fm.formatlist(exttestedwith, name=b'ver'),
1515 fm.formatlist(exttestedwith, name=b'ver'),
1514 )
1516 )
1515
1517
1516 fm.condwrite(
1518 fm.condwrite(
1517 ui.verbose and extbuglink,
1519 ui.verbose and extbuglink,
1518 b'buglink',
1520 b'buglink',
1519 _(b' bug reporting: %s\n'),
1521 _(b' bug reporting: %s\n'),
1520 extbuglink or b"",
1522 extbuglink or b"",
1521 )
1523 )
1522
1524
1523 fm.end()
1525 fm.end()
1524
1526
1525
1527
1526 @command(
1528 @command(
1527 b'debugfileset',
1529 b'debugfileset',
1528 [
1530 [
1529 (
1531 (
1530 b'r',
1532 b'r',
1531 b'rev',
1533 b'rev',
1532 b'',
1534 b'',
1533 _(b'apply the filespec on this revision'),
1535 _(b'apply the filespec on this revision'),
1534 _(b'REV'),
1536 _(b'REV'),
1535 ),
1537 ),
1536 (
1538 (
1537 b'',
1539 b'',
1538 b'all-files',
1540 b'all-files',
1539 False,
1541 False,
1540 _(b'test files from all revisions and working directory'),
1542 _(b'test files from all revisions and working directory'),
1541 ),
1543 ),
1542 (
1544 (
1543 b's',
1545 b's',
1544 b'show-matcher',
1546 b'show-matcher',
1545 None,
1547 None,
1546 _(b'print internal representation of matcher'),
1548 _(b'print internal representation of matcher'),
1547 ),
1549 ),
1548 (
1550 (
1549 b'p',
1551 b'p',
1550 b'show-stage',
1552 b'show-stage',
1551 [],
1553 [],
1552 _(b'print parsed tree at the given stage'),
1554 _(b'print parsed tree at the given stage'),
1553 _(b'NAME'),
1555 _(b'NAME'),
1554 ),
1556 ),
1555 ],
1557 ],
1556 _(b'[-r REV] [--all-files] [OPTION]... FILESPEC'),
1558 _(b'[-r REV] [--all-files] [OPTION]... FILESPEC'),
1557 )
1559 )
1558 def debugfileset(ui, repo, expr, **opts):
1560 def debugfileset(ui, repo, expr, **opts):
1559 '''parse and apply a fileset specification'''
1561 '''parse and apply a fileset specification'''
1560 from . import fileset
1562 from . import fileset
1561
1563
1562 fileset.symbols # force import of fileset so we have predicates to optimize
1564 fileset.symbols # force import of fileset so we have predicates to optimize
1563 opts = pycompat.byteskwargs(opts)
1565 opts = pycompat.byteskwargs(opts)
1564 ctx = logcmdutil.revsingle(repo, opts.get(b'rev'), None)
1566 ctx = logcmdutil.revsingle(repo, opts.get(b'rev'), None)
1565
1567
1566 stages = [
1568 stages = [
1567 (b'parsed', pycompat.identity),
1569 (b'parsed', pycompat.identity),
1568 (b'analyzed', filesetlang.analyze),
1570 (b'analyzed', filesetlang.analyze),
1569 (b'optimized', filesetlang.optimize),
1571 (b'optimized', filesetlang.optimize),
1570 ]
1572 ]
1571 stagenames = {n for n, f in stages}
1573 stagenames = {n for n, f in stages}
1572
1574
1573 showalways = set()
1575 showalways = set()
1574 if ui.verbose and not opts[b'show_stage']:
1576 if ui.verbose and not opts[b'show_stage']:
1575 # show parsed tree by --verbose (deprecated)
1577 # show parsed tree by --verbose (deprecated)
1576 showalways.add(b'parsed')
1578 showalways.add(b'parsed')
1577 if opts[b'show_stage'] == [b'all']:
1579 if opts[b'show_stage'] == [b'all']:
1578 showalways.update(stagenames)
1580 showalways.update(stagenames)
1579 else:
1581 else:
1580 for n in opts[b'show_stage']:
1582 for n in opts[b'show_stage']:
1581 if n not in stagenames:
1583 if n not in stagenames:
1582 raise error.Abort(_(b'invalid stage name: %s') % n)
1584 raise error.Abort(_(b'invalid stage name: %s') % n)
1583 showalways.update(opts[b'show_stage'])
1585 showalways.update(opts[b'show_stage'])
1584
1586
1585 tree = filesetlang.parse(expr)
1587 tree = filesetlang.parse(expr)
1586 for n, f in stages:
1588 for n, f in stages:
1587 tree = f(tree)
1589 tree = f(tree)
1588 if n in showalways:
1590 if n in showalways:
1589 if opts[b'show_stage'] or n != b'parsed':
1591 if opts[b'show_stage'] or n != b'parsed':
1590 ui.write(b"* %s:\n" % n)
1592 ui.write(b"* %s:\n" % n)
1591 ui.write(filesetlang.prettyformat(tree), b"\n")
1593 ui.write(filesetlang.prettyformat(tree), b"\n")
1592
1594
1593 files = set()
1595 files = set()
1594 if opts[b'all_files']:
1596 if opts[b'all_files']:
1595 for r in repo:
1597 for r in repo:
1596 c = repo[r]
1598 c = repo[r]
1597 files.update(c.files())
1599 files.update(c.files())
1598 files.update(c.substate)
1600 files.update(c.substate)
1599 if opts[b'all_files'] or ctx.rev() is None:
1601 if opts[b'all_files'] or ctx.rev() is None:
1600 wctx = repo[None]
1602 wctx = repo[None]
1601 files.update(
1603 files.update(
1602 repo.dirstate.walk(
1604 repo.dirstate.walk(
1603 scmutil.matchall(repo),
1605 scmutil.matchall(repo),
1604 subrepos=list(wctx.substate),
1606 subrepos=list(wctx.substate),
1605 unknown=True,
1607 unknown=True,
1606 ignored=True,
1608 ignored=True,
1607 )
1609 )
1608 )
1610 )
1609 files.update(wctx.substate)
1611 files.update(wctx.substate)
1610 else:
1612 else:
1611 files.update(ctx.files())
1613 files.update(ctx.files())
1612 files.update(ctx.substate)
1614 files.update(ctx.substate)
1613
1615
1614 m = ctx.matchfileset(repo.getcwd(), expr)
1616 m = ctx.matchfileset(repo.getcwd(), expr)
1615 if opts[b'show_matcher'] or (opts[b'show_matcher'] is None and ui.verbose):
1617 if opts[b'show_matcher'] or (opts[b'show_matcher'] is None and ui.verbose):
1616 ui.writenoi18n(b'* matcher:\n', stringutil.prettyrepr(m), b'\n')
1618 ui.writenoi18n(b'* matcher:\n', stringutil.prettyrepr(m), b'\n')
1617 for f in sorted(files):
1619 for f in sorted(files):
1618 if not m(f):
1620 if not m(f):
1619 continue
1621 continue
1620 ui.write(b"%s\n" % f)
1622 ui.write(b"%s\n" % f)
1621
1623
1622
1624
1623 @command(
1625 @command(
1624 b"debug-repair-issue6528",
1626 b"debug-repair-issue6528",
1625 [
1627 [
1626 (
1628 (
1627 b'',
1629 b'',
1628 b'to-report',
1630 b'to-report',
1629 b'',
1631 b'',
1630 _(b'build a report of affected revisions to this file'),
1632 _(b'build a report of affected revisions to this file'),
1631 _(b'FILE'),
1633 _(b'FILE'),
1632 ),
1634 ),
1633 (
1635 (
1634 b'',
1636 b'',
1635 b'from-report',
1637 b'from-report',
1636 b'',
1638 b'',
1637 _(b'repair revisions listed in this report file'),
1639 _(b'repair revisions listed in this report file'),
1638 _(b'FILE'),
1640 _(b'FILE'),
1639 ),
1641 ),
1640 (
1642 (
1641 b'',
1643 b'',
1642 b'paranoid',
1644 b'paranoid',
1643 False,
1645 False,
1644 _(b'check that both detection methods do the same thing'),
1646 _(b'check that both detection methods do the same thing'),
1645 ),
1647 ),
1646 ]
1648 ]
1647 + cmdutil.dryrunopts,
1649 + cmdutil.dryrunopts,
1648 )
1650 )
1649 def debug_repair_issue6528(ui, repo, **opts):
1651 def debug_repair_issue6528(ui, repo, **opts):
1650 """find affected revisions and repair them. See issue6528 for more details.
1652 """find affected revisions and repair them. See issue6528 for more details.
1651
1653
1652 The `--to-report` and `--from-report` flags allow you to cache and reuse the
1654 The `--to-report` and `--from-report` flags allow you to cache and reuse the
1653 computation of affected revisions for a given repository across clones.
1655 computation of affected revisions for a given repository across clones.
1654 The report format is line-based (with empty lines ignored):
1656 The report format is line-based (with empty lines ignored):
1655
1657
1656 ```
1658 ```
1657 <ascii-hex of the affected revision>,... <unencoded filelog index filename>
1659 <ascii-hex of the affected revision>,... <unencoded filelog index filename>
1658 ```
1660 ```
1659
1661
1660 There can be multiple broken revisions per filelog, they are separated by
1662 There can be multiple broken revisions per filelog, they are separated by
1661 a comma with no spaces. The only space is between the revision(s) and the
1663 a comma with no spaces. The only space is between the revision(s) and the
1662 filename.
1664 filename.
1663
1665
1664 Note that this does *not* mean that this repairs future affected revisions,
1666 Note that this does *not* mean that this repairs future affected revisions,
1665 that needs a separate fix at the exchange level that was introduced in
1667 that needs a separate fix at the exchange level that was introduced in
1666 Mercurial 5.9.1.
1668 Mercurial 5.9.1.
1667
1669
1668 There is a `--paranoid` flag to test that the fast implementation is correct
1670 There is a `--paranoid` flag to test that the fast implementation is correct
1669 by checking it against the slow implementation. Since this matter is quite
1671 by checking it against the slow implementation. Since this matter is quite
1670 urgent and testing every edge-case is probably quite costly, we use this
1672 urgent and testing every edge-case is probably quite costly, we use this
1671 method to test on large repositories as a fuzzing method of sorts.
1673 method to test on large repositories as a fuzzing method of sorts.
1672 """
1674 """
1673 cmdutil.check_incompatible_arguments(
1675 cmdutil.check_incompatible_arguments(
1674 opts, 'to_report', ['from_report', 'dry_run']
1676 opts, 'to_report', ['from_report', 'dry_run']
1675 )
1677 )
1676 dry_run = opts.get('dry_run')
1678 dry_run = opts.get('dry_run')
1677 to_report = opts.get('to_report')
1679 to_report = opts.get('to_report')
1678 from_report = opts.get('from_report')
1680 from_report = opts.get('from_report')
1679 paranoid = opts.get('paranoid')
1681 paranoid = opts.get('paranoid')
1680 # TODO maybe add filelog pattern and revision pattern parameters to help
1682 # TODO maybe add filelog pattern and revision pattern parameters to help
1681 # narrow down the search for users that know what they're looking for?
1683 # narrow down the search for users that know what they're looking for?
1682
1684
1683 if requirements.REVLOGV1_REQUIREMENT not in repo.requirements:
1685 if requirements.REVLOGV1_REQUIREMENT not in repo.requirements:
1684 msg = b"can only repair revlogv1 repositories, v2 is not affected"
1686 msg = b"can only repair revlogv1 repositories, v2 is not affected"
1685 raise error.Abort(_(msg))
1687 raise error.Abort(_(msg))
1686
1688
1687 rewrite.repair_issue6528(
1689 rewrite.repair_issue6528(
1688 ui,
1690 ui,
1689 repo,
1691 repo,
1690 dry_run=dry_run,
1692 dry_run=dry_run,
1691 to_report=to_report,
1693 to_report=to_report,
1692 from_report=from_report,
1694 from_report=from_report,
1693 paranoid=paranoid,
1695 paranoid=paranoid,
1694 )
1696 )
1695
1697
1696
1698
1697 @command(b'debugformat', [] + cmdutil.formatteropts)
1699 @command(b'debugformat', [] + cmdutil.formatteropts)
1698 def debugformat(ui, repo, **opts):
1700 def debugformat(ui, repo, **opts):
1699 """display format information about the current repository
1701 """display format information about the current repository
1700
1702
1701 Use --verbose to get extra information about current config value and
1703 Use --verbose to get extra information about current config value and
1702 Mercurial default."""
1704 Mercurial default."""
1703 opts = pycompat.byteskwargs(opts)
1705 opts = pycompat.byteskwargs(opts)
1704 maxvariantlength = max(len(fv.name) for fv in upgrade.allformatvariant)
1706 maxvariantlength = max(len(fv.name) for fv in upgrade.allformatvariant)
1705 maxvariantlength = max(len(b'format-variant'), maxvariantlength)
1707 maxvariantlength = max(len(b'format-variant'), maxvariantlength)
1706
1708
1707 def makeformatname(name):
1709 def makeformatname(name):
1708 return b'%s:' + (b' ' * (maxvariantlength - len(name)))
1710 return b'%s:' + (b' ' * (maxvariantlength - len(name)))
1709
1711
1710 fm = ui.formatter(b'debugformat', opts)
1712 fm = ui.formatter(b'debugformat', opts)
1711 if fm.isplain():
1713 if fm.isplain():
1712
1714
1713 def formatvalue(value):
1715 def formatvalue(value):
1714 if util.safehasattr(value, b'startswith'):
1716 if util.safehasattr(value, b'startswith'):
1715 return value
1717 return value
1716 if value:
1718 if value:
1717 return b'yes'
1719 return b'yes'
1718 else:
1720 else:
1719 return b'no'
1721 return b'no'
1720
1722
1721 else:
1723 else:
1722 formatvalue = pycompat.identity
1724 formatvalue = pycompat.identity
1723
1725
1724 fm.plain(b'format-variant')
1726 fm.plain(b'format-variant')
1725 fm.plain(b' ' * (maxvariantlength - len(b'format-variant')))
1727 fm.plain(b' ' * (maxvariantlength - len(b'format-variant')))
1726 fm.plain(b' repo')
1728 fm.plain(b' repo')
1727 if ui.verbose:
1729 if ui.verbose:
1728 fm.plain(b' config default')
1730 fm.plain(b' config default')
1729 fm.plain(b'\n')
1731 fm.plain(b'\n')
1730 for fv in upgrade.allformatvariant:
1732 for fv in upgrade.allformatvariant:
1731 fm.startitem()
1733 fm.startitem()
1732 repovalue = fv.fromrepo(repo)
1734 repovalue = fv.fromrepo(repo)
1733 configvalue = fv.fromconfig(repo)
1735 configvalue = fv.fromconfig(repo)
1734
1736
1735 if repovalue != configvalue:
1737 if repovalue != configvalue:
1736 namelabel = b'formatvariant.name.mismatchconfig'
1738 namelabel = b'formatvariant.name.mismatchconfig'
1737 repolabel = b'formatvariant.repo.mismatchconfig'
1739 repolabel = b'formatvariant.repo.mismatchconfig'
1738 elif repovalue != fv.default:
1740 elif repovalue != fv.default:
1739 namelabel = b'formatvariant.name.mismatchdefault'
1741 namelabel = b'formatvariant.name.mismatchdefault'
1740 repolabel = b'formatvariant.repo.mismatchdefault'
1742 repolabel = b'formatvariant.repo.mismatchdefault'
1741 else:
1743 else:
1742 namelabel = b'formatvariant.name.uptodate'
1744 namelabel = b'formatvariant.name.uptodate'
1743 repolabel = b'formatvariant.repo.uptodate'
1745 repolabel = b'formatvariant.repo.uptodate'
1744
1746
1745 fm.write(b'name', makeformatname(fv.name), fv.name, label=namelabel)
1747 fm.write(b'name', makeformatname(fv.name), fv.name, label=namelabel)
1746 fm.write(b'repo', b' %3s', formatvalue(repovalue), label=repolabel)
1748 fm.write(b'repo', b' %3s', formatvalue(repovalue), label=repolabel)
1747 if fv.default != configvalue:
1749 if fv.default != configvalue:
1748 configlabel = b'formatvariant.config.special'
1750 configlabel = b'formatvariant.config.special'
1749 else:
1751 else:
1750 configlabel = b'formatvariant.config.default'
1752 configlabel = b'formatvariant.config.default'
1751 fm.condwrite(
1753 fm.condwrite(
1752 ui.verbose,
1754 ui.verbose,
1753 b'config',
1755 b'config',
1754 b' %6s',
1756 b' %6s',
1755 formatvalue(configvalue),
1757 formatvalue(configvalue),
1756 label=configlabel,
1758 label=configlabel,
1757 )
1759 )
1758 fm.condwrite(
1760 fm.condwrite(
1759 ui.verbose,
1761 ui.verbose,
1760 b'default',
1762 b'default',
1761 b' %7s',
1763 b' %7s',
1762 formatvalue(fv.default),
1764 formatvalue(fv.default),
1763 label=b'formatvariant.default',
1765 label=b'formatvariant.default',
1764 )
1766 )
1765 fm.plain(b'\n')
1767 fm.plain(b'\n')
1766 fm.end()
1768 fm.end()
1767
1769
1768
1770
1769 @command(b'debugfsinfo', [], _(b'[PATH]'), norepo=True)
1771 @command(b'debugfsinfo', [], _(b'[PATH]'), norepo=True)
1770 def debugfsinfo(ui, path=b"."):
1772 def debugfsinfo(ui, path=b"."):
1771 """show information detected about current filesystem"""
1773 """show information detected about current filesystem"""
1772 ui.writenoi18n(b'path: %s\n' % path)
1774 ui.writenoi18n(b'path: %s\n' % path)
1773 ui.writenoi18n(
1775 ui.writenoi18n(
1774 b'mounted on: %s\n' % (util.getfsmountpoint(path) or b'(unknown)')
1776 b'mounted on: %s\n' % (util.getfsmountpoint(path) or b'(unknown)')
1775 )
1777 )
1776 ui.writenoi18n(b'exec: %s\n' % (util.checkexec(path) and b'yes' or b'no'))
1778 ui.writenoi18n(b'exec: %s\n' % (util.checkexec(path) and b'yes' or b'no'))
1777 ui.writenoi18n(b'fstype: %s\n' % (util.getfstype(path) or b'(unknown)'))
1779 ui.writenoi18n(b'fstype: %s\n' % (util.getfstype(path) or b'(unknown)'))
1778 ui.writenoi18n(
1780 ui.writenoi18n(
1779 b'symlink: %s\n' % (util.checklink(path) and b'yes' or b'no')
1781 b'symlink: %s\n' % (util.checklink(path) and b'yes' or b'no')
1780 )
1782 )
1781 ui.writenoi18n(
1783 ui.writenoi18n(
1782 b'hardlink: %s\n' % (util.checknlink(path) and b'yes' or b'no')
1784 b'hardlink: %s\n' % (util.checknlink(path) and b'yes' or b'no')
1783 )
1785 )
1784 casesensitive = b'(unknown)'
1786 casesensitive = b'(unknown)'
1785 try:
1787 try:
1786 with pycompat.namedtempfile(prefix=b'.debugfsinfo', dir=path) as f:
1788 with pycompat.namedtempfile(prefix=b'.debugfsinfo', dir=path) as f:
1787 casesensitive = util.fscasesensitive(f.name) and b'yes' or b'no'
1789 casesensitive = util.fscasesensitive(f.name) and b'yes' or b'no'
1788 except OSError:
1790 except OSError:
1789 pass
1791 pass
1790 ui.writenoi18n(b'case-sensitive: %s\n' % casesensitive)
1792 ui.writenoi18n(b'case-sensitive: %s\n' % casesensitive)
1791
1793
1792
1794
1793 @command(
1795 @command(
1794 b'debuggetbundle',
1796 b'debuggetbundle',
1795 [
1797 [
1796 (b'H', b'head', [], _(b'id of head node'), _(b'ID')),
1798 (b'H', b'head', [], _(b'id of head node'), _(b'ID')),
1797 (b'C', b'common', [], _(b'id of common node'), _(b'ID')),
1799 (b'C', b'common', [], _(b'id of common node'), _(b'ID')),
1798 (
1800 (
1799 b't',
1801 b't',
1800 b'type',
1802 b'type',
1801 b'bzip2',
1803 b'bzip2',
1802 _(b'bundle compression type to use'),
1804 _(b'bundle compression type to use'),
1803 _(b'TYPE'),
1805 _(b'TYPE'),
1804 ),
1806 ),
1805 ],
1807 ],
1806 _(b'REPO FILE [-H|-C ID]...'),
1808 _(b'REPO FILE [-H|-C ID]...'),
1807 norepo=True,
1809 norepo=True,
1808 )
1810 )
1809 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
1811 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
1810 """retrieves a bundle from a repo
1812 """retrieves a bundle from a repo
1811
1813
1812 Every ID must be a full-length hex node id string. Saves the bundle to the
1814 Every ID must be a full-length hex node id string. Saves the bundle to the
1813 given file.
1815 given file.
1814 """
1816 """
1815 opts = pycompat.byteskwargs(opts)
1817 opts = pycompat.byteskwargs(opts)
1816 repo = hg.peer(ui, opts, repopath)
1818 repo = hg.peer(ui, opts, repopath)
1817 if not repo.capable(b'getbundle'):
1819 if not repo.capable(b'getbundle'):
1818 raise error.Abort(b"getbundle() not supported by target repository")
1820 raise error.Abort(b"getbundle() not supported by target repository")
1819 args = {}
1821 args = {}
1820 if common:
1822 if common:
1821 args['common'] = [bin(s) for s in common]
1823 args['common'] = [bin(s) for s in common]
1822 if head:
1824 if head:
1823 args['heads'] = [bin(s) for s in head]
1825 args['heads'] = [bin(s) for s in head]
1824 # TODO: get desired bundlecaps from command line.
1826 # TODO: get desired bundlecaps from command line.
1825 args['bundlecaps'] = None
1827 args['bundlecaps'] = None
1826 bundle = repo.getbundle(b'debug', **args)
1828 bundle = repo.getbundle(b'debug', **args)
1827
1829
1828 bundletype = opts.get(b'type', b'bzip2').lower()
1830 bundletype = opts.get(b'type', b'bzip2').lower()
1829 btypes = {
1831 btypes = {
1830 b'none': b'HG10UN',
1832 b'none': b'HG10UN',
1831 b'bzip2': b'HG10BZ',
1833 b'bzip2': b'HG10BZ',
1832 b'gzip': b'HG10GZ',
1834 b'gzip': b'HG10GZ',
1833 b'bundle2': b'HG20',
1835 b'bundle2': b'HG20',
1834 }
1836 }
1835 bundletype = btypes.get(bundletype)
1837 bundletype = btypes.get(bundletype)
1836 if bundletype not in bundle2.bundletypes:
1838 if bundletype not in bundle2.bundletypes:
1837 raise error.Abort(_(b'unknown bundle type specified with --type'))
1839 raise error.Abort(_(b'unknown bundle type specified with --type'))
1838 bundle2.writebundle(ui, bundle, bundlepath, bundletype)
1840 bundle2.writebundle(ui, bundle, bundlepath, bundletype)
1839
1841
1840
1842
1841 @command(b'debugignore', [], b'[FILE]')
1843 @command(b'debugignore', [], b'[FILE]')
1842 def debugignore(ui, repo, *files, **opts):
1844 def debugignore(ui, repo, *files, **opts):
1843 """display the combined ignore pattern and information about ignored files
1845 """display the combined ignore pattern and information about ignored files
1844
1846
1845 With no argument display the combined ignore pattern.
1847 With no argument display the combined ignore pattern.
1846
1848
1847 Given space separated file names, shows if the given file is ignored and
1849 Given space separated file names, shows if the given file is ignored and
1848 if so, show the ignore rule (file and line number) that matched it.
1850 if so, show the ignore rule (file and line number) that matched it.
1849 """
1851 """
1850 ignore = repo.dirstate._ignore
1852 ignore = repo.dirstate._ignore
1851 if not files:
1853 if not files:
1852 # Show all the patterns
1854 # Show all the patterns
1853 ui.write(b"%s\n" % pycompat.byterepr(ignore))
1855 ui.write(b"%s\n" % pycompat.byterepr(ignore))
1854 else:
1856 else:
1855 m = scmutil.match(repo[None], pats=files)
1857 m = scmutil.match(repo[None], pats=files)
1856 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
1858 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
1857 for f in m.files():
1859 for f in m.files():
1858 nf = util.normpath(f)
1860 nf = util.normpath(f)
1859 ignored = None
1861 ignored = None
1860 ignoredata = None
1862 ignoredata = None
1861 if nf != b'.':
1863 if nf != b'.':
1862 if ignore(nf):
1864 if ignore(nf):
1863 ignored = nf
1865 ignored = nf
1864 ignoredata = repo.dirstate._ignorefileandline(nf)
1866 ignoredata = repo.dirstate._ignorefileandline(nf)
1865 else:
1867 else:
1866 for p in pathutil.finddirs(nf):
1868 for p in pathutil.finddirs(nf):
1867 if ignore(p):
1869 if ignore(p):
1868 ignored = p
1870 ignored = p
1869 ignoredata = repo.dirstate._ignorefileandline(p)
1871 ignoredata = repo.dirstate._ignorefileandline(p)
1870 break
1872 break
1871 if ignored:
1873 if ignored:
1872 if ignored == nf:
1874 if ignored == nf:
1873 ui.write(_(b"%s is ignored\n") % uipathfn(f))
1875 ui.write(_(b"%s is ignored\n") % uipathfn(f))
1874 else:
1876 else:
1875 ui.write(
1877 ui.write(
1876 _(
1878 _(
1877 b"%s is ignored because of "
1879 b"%s is ignored because of "
1878 b"containing directory %s\n"
1880 b"containing directory %s\n"
1879 )
1881 )
1880 % (uipathfn(f), ignored)
1882 % (uipathfn(f), ignored)
1881 )
1883 )
1882 ignorefile, lineno, line = ignoredata
1884 ignorefile, lineno, line = ignoredata
1883 ui.write(
1885 ui.write(
1884 _(b"(ignore rule in %s, line %d: '%s')\n")
1886 _(b"(ignore rule in %s, line %d: '%s')\n")
1885 % (ignorefile, lineno, line)
1887 % (ignorefile, lineno, line)
1886 )
1888 )
1887 else:
1889 else:
1888 ui.write(_(b"%s is not ignored\n") % uipathfn(f))
1890 ui.write(_(b"%s is not ignored\n") % uipathfn(f))
1889
1891
1890
1892
1891 @command(
1893 @command(
1892 b'debug-revlog-index|debugindex',
1894 b'debug-revlog-index|debugindex',
1893 cmdutil.debugrevlogopts + cmdutil.formatteropts,
1895 cmdutil.debugrevlogopts + cmdutil.formatteropts,
1894 _(b'-c|-m|FILE'),
1896 _(b'-c|-m|FILE'),
1895 )
1897 )
1896 def debugindex(ui, repo, file_=None, **opts):
1898 def debugindex(ui, repo, file_=None, **opts):
1897 """dump index data for a revlog"""
1899 """dump index data for a revlog"""
1898 opts = pycompat.byteskwargs(opts)
1900 opts = pycompat.byteskwargs(opts)
1899 store = cmdutil.openstorage(repo, b'debugindex', file_, opts)
1901 store = cmdutil.openstorage(repo, b'debugindex', file_, opts)
1900
1902
1901 fm = ui.formatter(b'debugindex', opts)
1903 fm = ui.formatter(b'debugindex', opts)
1902
1904
1903 revlog = getattr(store, b'_revlog', store)
1905 revlog = getattr(store, b'_revlog', store)
1904
1906
1905 return revlog_debug.debug_index(
1907 return revlog_debug.debug_index(
1906 ui,
1908 ui,
1907 repo,
1909 repo,
1908 formatter=fm,
1910 formatter=fm,
1909 revlog=revlog,
1911 revlog=revlog,
1910 full_node=ui.debugflag,
1912 full_node=ui.debugflag,
1911 )
1913 )
1912
1914
1913
1915
1914 @command(
1916 @command(
1915 b'debugindexdot',
1917 b'debugindexdot',
1916 cmdutil.debugrevlogopts,
1918 cmdutil.debugrevlogopts,
1917 _(b'-c|-m|FILE'),
1919 _(b'-c|-m|FILE'),
1918 optionalrepo=True,
1920 optionalrepo=True,
1919 )
1921 )
1920 def debugindexdot(ui, repo, file_=None, **opts):
1922 def debugindexdot(ui, repo, file_=None, **opts):
1921 """dump an index DAG as a graphviz dot file"""
1923 """dump an index DAG as a graphviz dot file"""
1922 opts = pycompat.byteskwargs(opts)
1924 opts = pycompat.byteskwargs(opts)
1923 r = cmdutil.openstorage(repo, b'debugindexdot', file_, opts)
1925 r = cmdutil.openstorage(repo, b'debugindexdot', file_, opts)
1924 ui.writenoi18n(b"digraph G {\n")
1926 ui.writenoi18n(b"digraph G {\n")
1925 for i in r:
1927 for i in r:
1926 node = r.node(i)
1928 node = r.node(i)
1927 pp = r.parents(node)
1929 pp = r.parents(node)
1928 ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i))
1930 ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i))
1929 if pp[1] != repo.nullid:
1931 if pp[1] != repo.nullid:
1930 ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i))
1932 ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i))
1931 ui.write(b"}\n")
1933 ui.write(b"}\n")
1932
1934
1933
1935
1934 @command(b'debugindexstats', [])
1936 @command(b'debugindexstats', [])
1935 def debugindexstats(ui, repo):
1937 def debugindexstats(ui, repo):
1936 """show stats related to the changelog index"""
1938 """show stats related to the changelog index"""
1937 repo.changelog.shortest(repo.nullid, 1)
1939 repo.changelog.shortest(repo.nullid, 1)
1938 index = repo.changelog.index
1940 index = repo.changelog.index
1939 if not util.safehasattr(index, b'stats'):
1941 if not util.safehasattr(index, b'stats'):
1940 raise error.Abort(_(b'debugindexstats only works with native code'))
1942 raise error.Abort(_(b'debugindexstats only works with native code'))
1941 for k, v in sorted(index.stats().items()):
1943 for k, v in sorted(index.stats().items()):
1942 ui.write(b'%s: %d\n' % (k, v))
1944 ui.write(b'%s: %d\n' % (k, v))
1943
1945
1944
1946
1945 @command(b'debuginstall', [] + cmdutil.formatteropts, b'', norepo=True)
1947 @command(b'debuginstall', [] + cmdutil.formatteropts, b'', norepo=True)
1946 def debuginstall(ui, **opts):
1948 def debuginstall(ui, **opts):
1947 """test Mercurial installation
1949 """test Mercurial installation
1948
1950
1949 Returns 0 on success.
1951 Returns 0 on success.
1950 """
1952 """
1951 opts = pycompat.byteskwargs(opts)
1953 opts = pycompat.byteskwargs(opts)
1952
1954
1953 problems = 0
1955 problems = 0
1954
1956
1955 fm = ui.formatter(b'debuginstall', opts)
1957 fm = ui.formatter(b'debuginstall', opts)
1956 fm.startitem()
1958 fm.startitem()
1957
1959
1958 # encoding might be unknown or wrong. don't translate these messages.
1960 # encoding might be unknown or wrong. don't translate these messages.
1959 fm.write(b'encoding', b"checking encoding (%s)...\n", encoding.encoding)
1961 fm.write(b'encoding', b"checking encoding (%s)...\n", encoding.encoding)
1960 err = None
1962 err = None
1961 try:
1963 try:
1962 codecs.lookup(pycompat.sysstr(encoding.encoding))
1964 codecs.lookup(pycompat.sysstr(encoding.encoding))
1963 except LookupError as inst:
1965 except LookupError as inst:
1964 err = stringutil.forcebytestr(inst)
1966 err = stringutil.forcebytestr(inst)
1965 problems += 1
1967 problems += 1
1966 fm.condwrite(
1968 fm.condwrite(
1967 err,
1969 err,
1968 b'encodingerror',
1970 b'encodingerror',
1969 b" %s\n (check that your locale is properly set)\n",
1971 b" %s\n (check that your locale is properly set)\n",
1970 err,
1972 err,
1971 )
1973 )
1972
1974
1973 # Python
1975 # Python
1974 pythonlib = None
1976 pythonlib = None
1975 if util.safehasattr(os, '__file__'):
1977 if util.safehasattr(os, '__file__'):
1976 pythonlib = os.path.dirname(pycompat.fsencode(os.__file__))
1978 pythonlib = os.path.dirname(pycompat.fsencode(os.__file__))
1977 elif getattr(sys, 'oxidized', False):
1979 elif getattr(sys, 'oxidized', False):
1978 pythonlib = pycompat.sysexecutable
1980 pythonlib = pycompat.sysexecutable
1979
1981
1980 fm.write(
1982 fm.write(
1981 b'pythonexe',
1983 b'pythonexe',
1982 _(b"checking Python executable (%s)\n"),
1984 _(b"checking Python executable (%s)\n"),
1983 pycompat.sysexecutable or _(b"unknown"),
1985 pycompat.sysexecutable or _(b"unknown"),
1984 )
1986 )
1985 fm.write(
1987 fm.write(
1986 b'pythonimplementation',
1988 b'pythonimplementation',
1987 _(b"checking Python implementation (%s)\n"),
1989 _(b"checking Python implementation (%s)\n"),
1988 pycompat.sysbytes(platform.python_implementation()),
1990 pycompat.sysbytes(platform.python_implementation()),
1989 )
1991 )
1990 fm.write(
1992 fm.write(
1991 b'pythonver',
1993 b'pythonver',
1992 _(b"checking Python version (%s)\n"),
1994 _(b"checking Python version (%s)\n"),
1993 (b"%d.%d.%d" % sys.version_info[:3]),
1995 (b"%d.%d.%d" % sys.version_info[:3]),
1994 )
1996 )
1995 fm.write(
1997 fm.write(
1996 b'pythonlib',
1998 b'pythonlib',
1997 _(b"checking Python lib (%s)...\n"),
1999 _(b"checking Python lib (%s)...\n"),
1998 pythonlib or _(b"unknown"),
2000 pythonlib or _(b"unknown"),
1999 )
2001 )
2000
2002
2001 try:
2003 try:
2002 from . import rustext # pytype: disable=import-error
2004 from . import rustext # pytype: disable=import-error
2003
2005
2004 rustext.__doc__ # trigger lazy import
2006 rustext.__doc__ # trigger lazy import
2005 except ImportError:
2007 except ImportError:
2006 rustext = None
2008 rustext = None
2007
2009
2008 security = set(sslutil.supportedprotocols)
2010 security = set(sslutil.supportedprotocols)
2009 if sslutil.hassni:
2011 if sslutil.hassni:
2010 security.add(b'sni')
2012 security.add(b'sni')
2011
2013
2012 fm.write(
2014 fm.write(
2013 b'pythonsecurity',
2015 b'pythonsecurity',
2014 _(b"checking Python security support (%s)\n"),
2016 _(b"checking Python security support (%s)\n"),
2015 fm.formatlist(sorted(security), name=b'protocol', fmt=b'%s', sep=b','),
2017 fm.formatlist(sorted(security), name=b'protocol', fmt=b'%s', sep=b','),
2016 )
2018 )
2017
2019
2018 # These are warnings, not errors. So don't increment problem count. This
2020 # These are warnings, not errors. So don't increment problem count. This
2019 # may change in the future.
2021 # may change in the future.
2020 if b'tls1.2' not in security:
2022 if b'tls1.2' not in security:
2021 fm.plain(
2023 fm.plain(
2022 _(
2024 _(
2023 b' TLS 1.2 not supported by Python install; '
2025 b' TLS 1.2 not supported by Python install; '
2024 b'network connections lack modern security\n'
2026 b'network connections lack modern security\n'
2025 )
2027 )
2026 )
2028 )
2027 if b'sni' not in security:
2029 if b'sni' not in security:
2028 fm.plain(
2030 fm.plain(
2029 _(
2031 _(
2030 b' SNI not supported by Python install; may have '
2032 b' SNI not supported by Python install; may have '
2031 b'connectivity issues with some servers\n'
2033 b'connectivity issues with some servers\n'
2032 )
2034 )
2033 )
2035 )
2034
2036
2035 fm.plain(
2037 fm.plain(
2036 _(
2038 _(
2037 b"checking Rust extensions (%s)\n"
2039 b"checking Rust extensions (%s)\n"
2038 % (b'missing' if rustext is None else b'installed')
2040 % (b'missing' if rustext is None else b'installed')
2039 ),
2041 ),
2040 )
2042 )
2041
2043
2042 # TODO print CA cert info
2044 # TODO print CA cert info
2043
2045
2044 # hg version
2046 # hg version
2045 hgver = util.version()
2047 hgver = util.version()
2046 fm.write(
2048 fm.write(
2047 b'hgver', _(b"checking Mercurial version (%s)\n"), hgver.split(b'+')[0]
2049 b'hgver', _(b"checking Mercurial version (%s)\n"), hgver.split(b'+')[0]
2048 )
2050 )
2049 fm.write(
2051 fm.write(
2050 b'hgverextra',
2052 b'hgverextra',
2051 _(b"checking Mercurial custom build (%s)\n"),
2053 _(b"checking Mercurial custom build (%s)\n"),
2052 b'+'.join(hgver.split(b'+')[1:]),
2054 b'+'.join(hgver.split(b'+')[1:]),
2053 )
2055 )
2054
2056
2055 # compiled modules
2057 # compiled modules
2056 hgmodules = None
2058 hgmodules = None
2057 if util.safehasattr(sys.modules[__name__], '__file__'):
2059 if util.safehasattr(sys.modules[__name__], '__file__'):
2058 hgmodules = os.path.dirname(pycompat.fsencode(__file__))
2060 hgmodules = os.path.dirname(pycompat.fsencode(__file__))
2059 elif getattr(sys, 'oxidized', False):
2061 elif getattr(sys, 'oxidized', False):
2060 hgmodules = pycompat.sysexecutable
2062 hgmodules = pycompat.sysexecutable
2061
2063
2062 fm.write(
2064 fm.write(
2063 b'hgmodulepolicy', _(b"checking module policy (%s)\n"), policy.policy
2065 b'hgmodulepolicy', _(b"checking module policy (%s)\n"), policy.policy
2064 )
2066 )
2065 fm.write(
2067 fm.write(
2066 b'hgmodules',
2068 b'hgmodules',
2067 _(b"checking installed modules (%s)...\n"),
2069 _(b"checking installed modules (%s)...\n"),
2068 hgmodules or _(b"unknown"),
2070 hgmodules or _(b"unknown"),
2069 )
2071 )
2070
2072
2071 rustandc = policy.policy in (b'rust+c', b'rust+c-allow')
2073 rustandc = policy.policy in (b'rust+c', b'rust+c-allow')
2072 rustext = rustandc # for now, that's the only case
2074 rustext = rustandc # for now, that's the only case
2073 cext = policy.policy in (b'c', b'allow') or rustandc
2075 cext = policy.policy in (b'c', b'allow') or rustandc
2074 nopure = cext or rustext
2076 nopure = cext or rustext
2075 if nopure:
2077 if nopure:
2076 err = None
2078 err = None
2077 try:
2079 try:
2078 if cext:
2080 if cext:
2079 from .cext import ( # pytype: disable=import-error
2081 from .cext import ( # pytype: disable=import-error
2080 base85,
2082 base85,
2081 bdiff,
2083 bdiff,
2082 mpatch,
2084 mpatch,
2083 osutil,
2085 osutil,
2084 )
2086 )
2085
2087
2086 # quiet pyflakes
2088 # quiet pyflakes
2087 dir(bdiff), dir(mpatch), dir(base85), dir(osutil)
2089 dir(bdiff), dir(mpatch), dir(base85), dir(osutil)
2088 if rustext:
2090 if rustext:
2089 from .rustext import ( # pytype: disable=import-error
2091 from .rustext import ( # pytype: disable=import-error
2090 ancestor,
2092 ancestor,
2091 dirstate,
2093 dirstate,
2092 )
2094 )
2093
2095
2094 dir(ancestor), dir(dirstate) # quiet pyflakes
2096 dir(ancestor), dir(dirstate) # quiet pyflakes
2095 except Exception as inst:
2097 except Exception as inst:
2096 err = stringutil.forcebytestr(inst)
2098 err = stringutil.forcebytestr(inst)
2097 problems += 1
2099 problems += 1
2098 fm.condwrite(err, b'extensionserror', b" %s\n", err)
2100 fm.condwrite(err, b'extensionserror', b" %s\n", err)
2099
2101
2100 compengines = util.compengines._engines.values()
2102 compengines = util.compengines._engines.values()
2101 fm.write(
2103 fm.write(
2102 b'compengines',
2104 b'compengines',
2103 _(b'checking registered compression engines (%s)\n'),
2105 _(b'checking registered compression engines (%s)\n'),
2104 fm.formatlist(
2106 fm.formatlist(
2105 sorted(e.name() for e in compengines),
2107 sorted(e.name() for e in compengines),
2106 name=b'compengine',
2108 name=b'compengine',
2107 fmt=b'%s',
2109 fmt=b'%s',
2108 sep=b', ',
2110 sep=b', ',
2109 ),
2111 ),
2110 )
2112 )
2111 fm.write(
2113 fm.write(
2112 b'compenginesavail',
2114 b'compenginesavail',
2113 _(b'checking available compression engines (%s)\n'),
2115 _(b'checking available compression engines (%s)\n'),
2114 fm.formatlist(
2116 fm.formatlist(
2115 sorted(e.name() for e in compengines if e.available()),
2117 sorted(e.name() for e in compengines if e.available()),
2116 name=b'compengine',
2118 name=b'compengine',
2117 fmt=b'%s',
2119 fmt=b'%s',
2118 sep=b', ',
2120 sep=b', ',
2119 ),
2121 ),
2120 )
2122 )
2121 wirecompengines = compression.compengines.supportedwireengines(
2123 wirecompengines = compression.compengines.supportedwireengines(
2122 compression.SERVERROLE
2124 compression.SERVERROLE
2123 )
2125 )
2124 fm.write(
2126 fm.write(
2125 b'compenginesserver',
2127 b'compenginesserver',
2126 _(
2128 _(
2127 b'checking available compression engines '
2129 b'checking available compression engines '
2128 b'for wire protocol (%s)\n'
2130 b'for wire protocol (%s)\n'
2129 ),
2131 ),
2130 fm.formatlist(
2132 fm.formatlist(
2131 [e.name() for e in wirecompengines if e.wireprotosupport()],
2133 [e.name() for e in wirecompengines if e.wireprotosupport()],
2132 name=b'compengine',
2134 name=b'compengine',
2133 fmt=b'%s',
2135 fmt=b'%s',
2134 sep=b', ',
2136 sep=b', ',
2135 ),
2137 ),
2136 )
2138 )
2137 re2 = b'missing'
2139 re2 = b'missing'
2138 if util._re2:
2140 if util._re2:
2139 re2 = b'available'
2141 re2 = b'available'
2140 fm.plain(_(b'checking "re2" regexp engine (%s)\n') % re2)
2142 fm.plain(_(b'checking "re2" regexp engine (%s)\n') % re2)
2141 fm.data(re2=bool(util._re2))
2143 fm.data(re2=bool(util._re2))
2142
2144
2143 # templates
2145 # templates
2144 p = templater.templatedir()
2146 p = templater.templatedir()
2145 fm.write(b'templatedirs', b'checking templates (%s)...\n', p or b'')
2147 fm.write(b'templatedirs', b'checking templates (%s)...\n', p or b'')
2146 fm.condwrite(not p, b'', _(b" no template directories found\n"))
2148 fm.condwrite(not p, b'', _(b" no template directories found\n"))
2147 if p:
2149 if p:
2148 (m, fp) = templater.try_open_template(b"map-cmdline.default")
2150 (m, fp) = templater.try_open_template(b"map-cmdline.default")
2149 if m:
2151 if m:
2150 # template found, check if it is working
2152 # template found, check if it is working
2151 err = None
2153 err = None
2152 try:
2154 try:
2153 templater.templater.frommapfile(m)
2155 templater.templater.frommapfile(m)
2154 except Exception as inst:
2156 except Exception as inst:
2155 err = stringutil.forcebytestr(inst)
2157 err = stringutil.forcebytestr(inst)
2156 p = None
2158 p = None
2157 fm.condwrite(err, b'defaulttemplateerror', b" %s\n", err)
2159 fm.condwrite(err, b'defaulttemplateerror', b" %s\n", err)
2158 else:
2160 else:
2159 p = None
2161 p = None
2160 fm.condwrite(
2162 fm.condwrite(
2161 p, b'defaulttemplate', _(b"checking default template (%s)\n"), m
2163 p, b'defaulttemplate', _(b"checking default template (%s)\n"), m
2162 )
2164 )
2163 fm.condwrite(
2165 fm.condwrite(
2164 not m,
2166 not m,
2165 b'defaulttemplatenotfound',
2167 b'defaulttemplatenotfound',
2166 _(b" template '%s' not found\n"),
2168 _(b" template '%s' not found\n"),
2167 b"default",
2169 b"default",
2168 )
2170 )
2169 if not p:
2171 if not p:
2170 problems += 1
2172 problems += 1
2171 fm.condwrite(
2173 fm.condwrite(
2172 not p, b'', _(b" (templates seem to have been installed incorrectly)\n")
2174 not p, b'', _(b" (templates seem to have been installed incorrectly)\n")
2173 )
2175 )
2174
2176
2175 # editor
2177 # editor
2176 editor = ui.geteditor()
2178 editor = ui.geteditor()
2177 editor = util.expandpath(editor)
2179 editor = util.expandpath(editor)
2178 editorbin = procutil.shellsplit(editor)[0]
2180 editorbin = procutil.shellsplit(editor)[0]
2179 fm.write(b'editor', _(b"checking commit editor... (%s)\n"), editorbin)
2181 fm.write(b'editor', _(b"checking commit editor... (%s)\n"), editorbin)
2180 cmdpath = procutil.findexe(editorbin)
2182 cmdpath = procutil.findexe(editorbin)
2181 fm.condwrite(
2183 fm.condwrite(
2182 not cmdpath and editor == b'vi',
2184 not cmdpath and editor == b'vi',
2183 b'vinotfound',
2185 b'vinotfound',
2184 _(
2186 _(
2185 b" No commit editor set and can't find %s in PATH\n"
2187 b" No commit editor set and can't find %s in PATH\n"
2186 b" (specify a commit editor in your configuration"
2188 b" (specify a commit editor in your configuration"
2187 b" file)\n"
2189 b" file)\n"
2188 ),
2190 ),
2189 not cmdpath and editor == b'vi' and editorbin,
2191 not cmdpath and editor == b'vi' and editorbin,
2190 )
2192 )
2191 fm.condwrite(
2193 fm.condwrite(
2192 not cmdpath and editor != b'vi',
2194 not cmdpath and editor != b'vi',
2193 b'editornotfound',
2195 b'editornotfound',
2194 _(
2196 _(
2195 b" Can't find editor '%s' in PATH\n"
2197 b" Can't find editor '%s' in PATH\n"
2196 b" (specify a commit editor in your configuration"
2198 b" (specify a commit editor in your configuration"
2197 b" file)\n"
2199 b" file)\n"
2198 ),
2200 ),
2199 not cmdpath and editorbin,
2201 not cmdpath and editorbin,
2200 )
2202 )
2201 if not cmdpath and editor != b'vi':
2203 if not cmdpath and editor != b'vi':
2202 problems += 1
2204 problems += 1
2203
2205
2204 # check username
2206 # check username
2205 username = None
2207 username = None
2206 err = None
2208 err = None
2207 try:
2209 try:
2208 username = ui.username()
2210 username = ui.username()
2209 except error.Abort as e:
2211 except error.Abort as e:
2210 err = e.message
2212 err = e.message
2211 problems += 1
2213 problems += 1
2212
2214
2213 fm.condwrite(
2215 fm.condwrite(
2214 username, b'username', _(b"checking username (%s)\n"), username
2216 username, b'username', _(b"checking username (%s)\n"), username
2215 )
2217 )
2216 fm.condwrite(
2218 fm.condwrite(
2217 err,
2219 err,
2218 b'usernameerror',
2220 b'usernameerror',
2219 _(
2221 _(
2220 b"checking username...\n %s\n"
2222 b"checking username...\n %s\n"
2221 b" (specify a username in your configuration file)\n"
2223 b" (specify a username in your configuration file)\n"
2222 ),
2224 ),
2223 err,
2225 err,
2224 )
2226 )
2225
2227
2226 for name, mod in extensions.extensions():
2228 for name, mod in extensions.extensions():
2227 handler = getattr(mod, 'debuginstall', None)
2229 handler = getattr(mod, 'debuginstall', None)
2228 if handler is not None:
2230 if handler is not None:
2229 problems += handler(ui, fm)
2231 problems += handler(ui, fm)
2230
2232
2231 fm.condwrite(not problems, b'', _(b"no problems detected\n"))
2233 fm.condwrite(not problems, b'', _(b"no problems detected\n"))
2232 if not problems:
2234 if not problems:
2233 fm.data(problems=problems)
2235 fm.data(problems=problems)
2234 fm.condwrite(
2236 fm.condwrite(
2235 problems,
2237 problems,
2236 b'problems',
2238 b'problems',
2237 _(b"%d problems detected, please check your install!\n"),
2239 _(b"%d problems detected, please check your install!\n"),
2238 problems,
2240 problems,
2239 )
2241 )
2240 fm.end()
2242 fm.end()
2241
2243
2242 return problems
2244 return problems
2243
2245
2244
2246
2245 @command(b'debugknown', [], _(b'REPO ID...'), norepo=True)
2247 @command(b'debugknown', [], _(b'REPO ID...'), norepo=True)
2246 def debugknown(ui, repopath, *ids, **opts):
2248 def debugknown(ui, repopath, *ids, **opts):
2247 """test whether node ids are known to a repo
2249 """test whether node ids are known to a repo
2248
2250
2249 Every ID must be a full-length hex node id string. Returns a list of 0s
2251 Every ID must be a full-length hex node id string. Returns a list of 0s
2250 and 1s indicating unknown/known.
2252 and 1s indicating unknown/known.
2251 """
2253 """
2252 opts = pycompat.byteskwargs(opts)
2254 opts = pycompat.byteskwargs(opts)
2253 repo = hg.peer(ui, opts, repopath)
2255 repo = hg.peer(ui, opts, repopath)
2254 if not repo.capable(b'known'):
2256 if not repo.capable(b'known'):
2255 raise error.Abort(b"known() not supported by target repository")
2257 raise error.Abort(b"known() not supported by target repository")
2256 flags = repo.known([bin(s) for s in ids])
2258 flags = repo.known([bin(s) for s in ids])
2257 ui.write(b"%s\n" % (b"".join([f and b"1" or b"0" for f in flags])))
2259 ui.write(b"%s\n" % (b"".join([f and b"1" or b"0" for f in flags])))
2258
2260
2259
2261
2260 @command(b'debuglabelcomplete', [], _(b'LABEL...'))
2262 @command(b'debuglabelcomplete', [], _(b'LABEL...'))
2261 def debuglabelcomplete(ui, repo, *args):
2263 def debuglabelcomplete(ui, repo, *args):
2262 '''backwards compatibility with old bash completion scripts (DEPRECATED)'''
2264 '''backwards compatibility with old bash completion scripts (DEPRECATED)'''
2263 debugnamecomplete(ui, repo, *args)
2265 debugnamecomplete(ui, repo, *args)
2264
2266
2265
2267
2266 @command(
2268 @command(
2267 b'debuglocks',
2269 b'debuglocks',
2268 [
2270 [
2269 (b'L', b'force-free-lock', None, _(b'free the store lock (DANGEROUS)')),
2271 (b'L', b'force-free-lock', None, _(b'free the store lock (DANGEROUS)')),
2270 (
2272 (
2271 b'W',
2273 b'W',
2272 b'force-free-wlock',
2274 b'force-free-wlock',
2273 None,
2275 None,
2274 _(b'free the working state lock (DANGEROUS)'),
2276 _(b'free the working state lock (DANGEROUS)'),
2275 ),
2277 ),
2276 (b's', b'set-lock', None, _(b'set the store lock until stopped')),
2278 (b's', b'set-lock', None, _(b'set the store lock until stopped')),
2277 (
2279 (
2278 b'S',
2280 b'S',
2279 b'set-wlock',
2281 b'set-wlock',
2280 None,
2282 None,
2281 _(b'set the working state lock until stopped'),
2283 _(b'set the working state lock until stopped'),
2282 ),
2284 ),
2283 ],
2285 ],
2284 _(b'[OPTION]...'),
2286 _(b'[OPTION]...'),
2285 )
2287 )
2286 def debuglocks(ui, repo, **opts):
2288 def debuglocks(ui, repo, **opts):
2287 """show or modify state of locks
2289 """show or modify state of locks
2288
2290
2289 By default, this command will show which locks are held. This
2291 By default, this command will show which locks are held. This
2290 includes the user and process holding the lock, the amount of time
2292 includes the user and process holding the lock, the amount of time
2291 the lock has been held, and the machine name where the process is
2293 the lock has been held, and the machine name where the process is
2292 running if it's not local.
2294 running if it's not local.
2293
2295
2294 Locks protect the integrity of Mercurial's data, so should be
2296 Locks protect the integrity of Mercurial's data, so should be
2295 treated with care. System crashes or other interruptions may cause
2297 treated with care. System crashes or other interruptions may cause
2296 locks to not be properly released, though Mercurial will usually
2298 locks to not be properly released, though Mercurial will usually
2297 detect and remove such stale locks automatically.
2299 detect and remove such stale locks automatically.
2298
2300
2299 However, detecting stale locks may not always be possible (for
2301 However, detecting stale locks may not always be possible (for
2300 instance, on a shared filesystem). Removing locks may also be
2302 instance, on a shared filesystem). Removing locks may also be
2301 blocked by filesystem permissions.
2303 blocked by filesystem permissions.
2302
2304
2303 Setting a lock will prevent other commands from changing the data.
2305 Setting a lock will prevent other commands from changing the data.
2304 The command will wait until an interruption (SIGINT, SIGTERM, ...) occurs.
2306 The command will wait until an interruption (SIGINT, SIGTERM, ...) occurs.
2305 The set locks are removed when the command exits.
2307 The set locks are removed when the command exits.
2306
2308
2307 Returns 0 if no locks are held.
2309 Returns 0 if no locks are held.
2308
2310
2309 """
2311 """
2310
2312
2311 if opts.get('force_free_lock'):
2313 if opts.get('force_free_lock'):
2312 repo.svfs.tryunlink(b'lock')
2314 repo.svfs.tryunlink(b'lock')
2313 if opts.get('force_free_wlock'):
2315 if opts.get('force_free_wlock'):
2314 repo.vfs.tryunlink(b'wlock')
2316 repo.vfs.tryunlink(b'wlock')
2315 if opts.get('force_free_lock') or opts.get('force_free_wlock'):
2317 if opts.get('force_free_lock') or opts.get('force_free_wlock'):
2316 return 0
2318 return 0
2317
2319
2318 locks = []
2320 locks = []
2319 try:
2321 try:
2320 if opts.get('set_wlock'):
2322 if opts.get('set_wlock'):
2321 try:
2323 try:
2322 locks.append(repo.wlock(False))
2324 locks.append(repo.wlock(False))
2323 except error.LockHeld:
2325 except error.LockHeld:
2324 raise error.Abort(_(b'wlock is already held'))
2326 raise error.Abort(_(b'wlock is already held'))
2325 if opts.get('set_lock'):
2327 if opts.get('set_lock'):
2326 try:
2328 try:
2327 locks.append(repo.lock(False))
2329 locks.append(repo.lock(False))
2328 except error.LockHeld:
2330 except error.LockHeld:
2329 raise error.Abort(_(b'lock is already held'))
2331 raise error.Abort(_(b'lock is already held'))
2330 if len(locks):
2332 if len(locks):
2331 try:
2333 try:
2332 if ui.interactive():
2334 if ui.interactive():
2333 prompt = _(b"ready to release the lock (y)? $$ &Yes")
2335 prompt = _(b"ready to release the lock (y)? $$ &Yes")
2334 ui.promptchoice(prompt)
2336 ui.promptchoice(prompt)
2335 else:
2337 else:
2336 msg = b"%d locks held, waiting for signal\n"
2338 msg = b"%d locks held, waiting for signal\n"
2337 msg %= len(locks)
2339 msg %= len(locks)
2338 ui.status(msg)
2340 ui.status(msg)
2339 while True: # XXX wait for a signal
2341 while True: # XXX wait for a signal
2340 time.sleep(0.1)
2342 time.sleep(0.1)
2341 except KeyboardInterrupt:
2343 except KeyboardInterrupt:
2342 msg = b"signal-received releasing locks\n"
2344 msg = b"signal-received releasing locks\n"
2343 ui.status(msg)
2345 ui.status(msg)
2344 return 0
2346 return 0
2345 finally:
2347 finally:
2346 release(*locks)
2348 release(*locks)
2347
2349
2348 now = time.time()
2350 now = time.time()
2349 held = 0
2351 held = 0
2350
2352
2351 def report(vfs, name, method):
2353 def report(vfs, name, method):
2352 # this causes stale locks to get reaped for more accurate reporting
2354 # this causes stale locks to get reaped for more accurate reporting
2353 try:
2355 try:
2354 l = method(False)
2356 l = method(False)
2355 except error.LockHeld:
2357 except error.LockHeld:
2356 l = None
2358 l = None
2357
2359
2358 if l:
2360 if l:
2359 l.release()
2361 l.release()
2360 else:
2362 else:
2361 try:
2363 try:
2362 st = vfs.lstat(name)
2364 st = vfs.lstat(name)
2363 age = now - st[stat.ST_MTIME]
2365 age = now - st[stat.ST_MTIME]
2364 user = util.username(st.st_uid)
2366 user = util.username(st.st_uid)
2365 locker = vfs.readlock(name)
2367 locker = vfs.readlock(name)
2366 if b":" in locker:
2368 if b":" in locker:
2367 host, pid = locker.split(b':')
2369 host, pid = locker.split(b':')
2368 if host == socket.gethostname():
2370 if host == socket.gethostname():
2369 locker = b'user %s, process %s' % (user or b'None', pid)
2371 locker = b'user %s, process %s' % (user or b'None', pid)
2370 else:
2372 else:
2371 locker = b'user %s, process %s, host %s' % (
2373 locker = b'user %s, process %s, host %s' % (
2372 user or b'None',
2374 user or b'None',
2373 pid,
2375 pid,
2374 host,
2376 host,
2375 )
2377 )
2376 ui.writenoi18n(b"%-6s %s (%ds)\n" % (name + b":", locker, age))
2378 ui.writenoi18n(b"%-6s %s (%ds)\n" % (name + b":", locker, age))
2377 return 1
2379 return 1
2378 except FileNotFoundError:
2380 except FileNotFoundError:
2379 pass
2381 pass
2380
2382
2381 ui.writenoi18n(b"%-6s free\n" % (name + b":"))
2383 ui.writenoi18n(b"%-6s free\n" % (name + b":"))
2382 return 0
2384 return 0
2383
2385
2384 held += report(repo.svfs, b"lock", repo.lock)
2386 held += report(repo.svfs, b"lock", repo.lock)
2385 held += report(repo.vfs, b"wlock", repo.wlock)
2387 held += report(repo.vfs, b"wlock", repo.wlock)
2386
2388
2387 return held
2389 return held
2388
2390
2389
2391
2390 @command(
2392 @command(
2391 b'debugmanifestfulltextcache',
2393 b'debugmanifestfulltextcache',
2392 [
2394 [
2393 (b'', b'clear', False, _(b'clear the cache')),
2395 (b'', b'clear', False, _(b'clear the cache')),
2394 (
2396 (
2395 b'a',
2397 b'a',
2396 b'add',
2398 b'add',
2397 [],
2399 [],
2398 _(b'add the given manifest nodes to the cache'),
2400 _(b'add the given manifest nodes to the cache'),
2399 _(b'NODE'),
2401 _(b'NODE'),
2400 ),
2402 ),
2401 ],
2403 ],
2402 b'',
2404 b'',
2403 )
2405 )
2404 def debugmanifestfulltextcache(ui, repo, add=(), **opts):
2406 def debugmanifestfulltextcache(ui, repo, add=(), **opts):
2405 """show, clear or amend the contents of the manifest fulltext cache"""
2407 """show, clear or amend the contents of the manifest fulltext cache"""
2406
2408
2407 def getcache():
2409 def getcache():
2408 r = repo.manifestlog.getstorage(b'')
2410 r = repo.manifestlog.getstorage(b'')
2409 try:
2411 try:
2410 return r._fulltextcache
2412 return r._fulltextcache
2411 except AttributeError:
2413 except AttributeError:
2412 msg = _(
2414 msg = _(
2413 b"Current revlog implementation doesn't appear to have a "
2415 b"Current revlog implementation doesn't appear to have a "
2414 b"manifest fulltext cache\n"
2416 b"manifest fulltext cache\n"
2415 )
2417 )
2416 raise error.Abort(msg)
2418 raise error.Abort(msg)
2417
2419
2418 if opts.get('clear'):
2420 if opts.get('clear'):
2419 with repo.wlock():
2421 with repo.wlock():
2420 cache = getcache()
2422 cache = getcache()
2421 cache.clear(clear_persisted_data=True)
2423 cache.clear(clear_persisted_data=True)
2422 return
2424 return
2423
2425
2424 if add:
2426 if add:
2425 with repo.wlock():
2427 with repo.wlock():
2426 m = repo.manifestlog
2428 m = repo.manifestlog
2427 store = m.getstorage(b'')
2429 store = m.getstorage(b'')
2428 for n in add:
2430 for n in add:
2429 try:
2431 try:
2430 manifest = m[store.lookup(n)]
2432 manifest = m[store.lookup(n)]
2431 except error.LookupError as e:
2433 except error.LookupError as e:
2432 raise error.Abort(
2434 raise error.Abort(
2433 bytes(e), hint=b"Check your manifest node id"
2435 bytes(e), hint=b"Check your manifest node id"
2434 )
2436 )
2435 manifest.read() # stores revisision in cache too
2437 manifest.read() # stores revisision in cache too
2436 return
2438 return
2437
2439
2438 cache = getcache()
2440 cache = getcache()
2439 if not len(cache):
2441 if not len(cache):
2440 ui.write(_(b'cache empty\n'))
2442 ui.write(_(b'cache empty\n'))
2441 else:
2443 else:
2442 ui.write(
2444 ui.write(
2443 _(
2445 _(
2444 b'cache contains %d manifest entries, in order of most to '
2446 b'cache contains %d manifest entries, in order of most to '
2445 b'least recent:\n'
2447 b'least recent:\n'
2446 )
2448 )
2447 % (len(cache),)
2449 % (len(cache),)
2448 )
2450 )
2449 totalsize = 0
2451 totalsize = 0
2450 for nodeid in cache:
2452 for nodeid in cache:
2451 # Use cache.get to not update the LRU order
2453 # Use cache.get to not update the LRU order
2452 data = cache.peek(nodeid)
2454 data = cache.peek(nodeid)
2453 size = len(data)
2455 size = len(data)
2454 totalsize += size + 24 # 20 bytes nodeid, 4 bytes size
2456 totalsize += size + 24 # 20 bytes nodeid, 4 bytes size
2455 ui.write(
2457 ui.write(
2456 _(b'id: %s, size %s\n') % (hex(nodeid), util.bytecount(size))
2458 _(b'id: %s, size %s\n') % (hex(nodeid), util.bytecount(size))
2457 )
2459 )
2458 ondisk = cache._opener.stat(b'manifestfulltextcache').st_size
2460 ondisk = cache._opener.stat(b'manifestfulltextcache').st_size
2459 ui.write(
2461 ui.write(
2460 _(b'total cache data size %s, on-disk %s\n')
2462 _(b'total cache data size %s, on-disk %s\n')
2461 % (util.bytecount(totalsize), util.bytecount(ondisk))
2463 % (util.bytecount(totalsize), util.bytecount(ondisk))
2462 )
2464 )
2463
2465
2464
2466
2465 @command(b'debugmergestate', [] + cmdutil.templateopts, b'')
2467 @command(b'debugmergestate', [] + cmdutil.templateopts, b'')
2466 def debugmergestate(ui, repo, *args, **opts):
2468 def debugmergestate(ui, repo, *args, **opts):
2467 """print merge state
2469 """print merge state
2468
2470
2469 Use --verbose to print out information about whether v1 or v2 merge state
2471 Use --verbose to print out information about whether v1 or v2 merge state
2470 was chosen."""
2472 was chosen."""
2471
2473
2472 if ui.verbose:
2474 if ui.verbose:
2473 ms = mergestatemod.mergestate(repo)
2475 ms = mergestatemod.mergestate(repo)
2474
2476
2475 # sort so that reasonable information is on top
2477 # sort so that reasonable information is on top
2476 v1records = ms._readrecordsv1()
2478 v1records = ms._readrecordsv1()
2477 v2records = ms._readrecordsv2()
2479 v2records = ms._readrecordsv2()
2478
2480
2479 if not v1records and not v2records:
2481 if not v1records and not v2records:
2480 pass
2482 pass
2481 elif not v2records:
2483 elif not v2records:
2482 ui.writenoi18n(b'no version 2 merge state\n')
2484 ui.writenoi18n(b'no version 2 merge state\n')
2483 elif ms._v1v2match(v1records, v2records):
2485 elif ms._v1v2match(v1records, v2records):
2484 ui.writenoi18n(b'v1 and v2 states match: using v2\n')
2486 ui.writenoi18n(b'v1 and v2 states match: using v2\n')
2485 else:
2487 else:
2486 ui.writenoi18n(b'v1 and v2 states mismatch: using v1\n')
2488 ui.writenoi18n(b'v1 and v2 states mismatch: using v1\n')
2487
2489
2488 opts = pycompat.byteskwargs(opts)
2490 opts = pycompat.byteskwargs(opts)
2489 if not opts[b'template']:
2491 if not opts[b'template']:
2490 opts[b'template'] = (
2492 opts[b'template'] = (
2491 b'{if(commits, "", "no merge state found\n")}'
2493 b'{if(commits, "", "no merge state found\n")}'
2492 b'{commits % "{name}{if(label, " ({label})")}: {node}\n"}'
2494 b'{commits % "{name}{if(label, " ({label})")}: {node}\n"}'
2493 b'{files % "file: {path} (state \\"{state}\\")\n'
2495 b'{files % "file: {path} (state \\"{state}\\")\n'
2494 b'{if(local_path, "'
2496 b'{if(local_path, "'
2495 b' local path: {local_path} (hash {local_key}, flags \\"{local_flags}\\")\n'
2497 b' local path: {local_path} (hash {local_key}, flags \\"{local_flags}\\")\n'
2496 b' ancestor path: {ancestor_path} (node {ancestor_node})\n'
2498 b' ancestor path: {ancestor_path} (node {ancestor_node})\n'
2497 b' other path: {other_path} (node {other_node})\n'
2499 b' other path: {other_path} (node {other_node})\n'
2498 b'")}'
2500 b'")}'
2499 b'{if(rename_side, "'
2501 b'{if(rename_side, "'
2500 b' rename side: {rename_side}\n'
2502 b' rename side: {rename_side}\n'
2501 b' renamed path: {renamed_path}\n'
2503 b' renamed path: {renamed_path}\n'
2502 b'")}'
2504 b'")}'
2503 b'{extras % " extra: {key} = {value}\n"}'
2505 b'{extras % " extra: {key} = {value}\n"}'
2504 b'"}'
2506 b'"}'
2505 b'{extras % "extra: {file} ({key} = {value})\n"}'
2507 b'{extras % "extra: {file} ({key} = {value})\n"}'
2506 )
2508 )
2507
2509
2508 ms = mergestatemod.mergestate.read(repo)
2510 ms = mergestatemod.mergestate.read(repo)
2509
2511
2510 fm = ui.formatter(b'debugmergestate', opts)
2512 fm = ui.formatter(b'debugmergestate', opts)
2511 fm.startitem()
2513 fm.startitem()
2512
2514
2513 fm_commits = fm.nested(b'commits')
2515 fm_commits = fm.nested(b'commits')
2514 if ms.active():
2516 if ms.active():
2515 for name, node, label_index in (
2517 for name, node, label_index in (
2516 (b'local', ms.local, 0),
2518 (b'local', ms.local, 0),
2517 (b'other', ms.other, 1),
2519 (b'other', ms.other, 1),
2518 ):
2520 ):
2519 fm_commits.startitem()
2521 fm_commits.startitem()
2520 fm_commits.data(name=name)
2522 fm_commits.data(name=name)
2521 fm_commits.data(node=hex(node))
2523 fm_commits.data(node=hex(node))
2522 if ms._labels and len(ms._labels) > label_index:
2524 if ms._labels and len(ms._labels) > label_index:
2523 fm_commits.data(label=ms._labels[label_index])
2525 fm_commits.data(label=ms._labels[label_index])
2524 fm_commits.end()
2526 fm_commits.end()
2525
2527
2526 fm_files = fm.nested(b'files')
2528 fm_files = fm.nested(b'files')
2527 if ms.active():
2529 if ms.active():
2528 for f in ms:
2530 for f in ms:
2529 fm_files.startitem()
2531 fm_files.startitem()
2530 fm_files.data(path=f)
2532 fm_files.data(path=f)
2531 state = ms._state[f]
2533 state = ms._state[f]
2532 fm_files.data(state=state[0])
2534 fm_files.data(state=state[0])
2533 if state[0] in (
2535 if state[0] in (
2534 mergestatemod.MERGE_RECORD_UNRESOLVED,
2536 mergestatemod.MERGE_RECORD_UNRESOLVED,
2535 mergestatemod.MERGE_RECORD_RESOLVED,
2537 mergestatemod.MERGE_RECORD_RESOLVED,
2536 ):
2538 ):
2537 fm_files.data(local_key=state[1])
2539 fm_files.data(local_key=state[1])
2538 fm_files.data(local_path=state[2])
2540 fm_files.data(local_path=state[2])
2539 fm_files.data(ancestor_path=state[3])
2541 fm_files.data(ancestor_path=state[3])
2540 fm_files.data(ancestor_node=state[4])
2542 fm_files.data(ancestor_node=state[4])
2541 fm_files.data(other_path=state[5])
2543 fm_files.data(other_path=state[5])
2542 fm_files.data(other_node=state[6])
2544 fm_files.data(other_node=state[6])
2543 fm_files.data(local_flags=state[7])
2545 fm_files.data(local_flags=state[7])
2544 elif state[0] in (
2546 elif state[0] in (
2545 mergestatemod.MERGE_RECORD_UNRESOLVED_PATH,
2547 mergestatemod.MERGE_RECORD_UNRESOLVED_PATH,
2546 mergestatemod.MERGE_RECORD_RESOLVED_PATH,
2548 mergestatemod.MERGE_RECORD_RESOLVED_PATH,
2547 ):
2549 ):
2548 fm_files.data(renamed_path=state[1])
2550 fm_files.data(renamed_path=state[1])
2549 fm_files.data(rename_side=state[2])
2551 fm_files.data(rename_side=state[2])
2550 fm_extras = fm_files.nested(b'extras')
2552 fm_extras = fm_files.nested(b'extras')
2551 for k, v in sorted(ms.extras(f).items()):
2553 for k, v in sorted(ms.extras(f).items()):
2552 fm_extras.startitem()
2554 fm_extras.startitem()
2553 fm_extras.data(key=k)
2555 fm_extras.data(key=k)
2554 fm_extras.data(value=v)
2556 fm_extras.data(value=v)
2555 fm_extras.end()
2557 fm_extras.end()
2556
2558
2557 fm_files.end()
2559 fm_files.end()
2558
2560
2559 fm_extras = fm.nested(b'extras')
2561 fm_extras = fm.nested(b'extras')
2560 for f, d in sorted(ms.allextras().items()):
2562 for f, d in sorted(ms.allextras().items()):
2561 if f in ms:
2563 if f in ms:
2562 # If file is in mergestate, we have already processed it's extras
2564 # If file is in mergestate, we have already processed it's extras
2563 continue
2565 continue
2564 for k, v in d.items():
2566 for k, v in d.items():
2565 fm_extras.startitem()
2567 fm_extras.startitem()
2566 fm_extras.data(file=f)
2568 fm_extras.data(file=f)
2567 fm_extras.data(key=k)
2569 fm_extras.data(key=k)
2568 fm_extras.data(value=v)
2570 fm_extras.data(value=v)
2569 fm_extras.end()
2571 fm_extras.end()
2570
2572
2571 fm.end()
2573 fm.end()
2572
2574
2573
2575
2574 @command(b'debugnamecomplete', [], _(b'NAME...'))
2576 @command(b'debugnamecomplete', [], _(b'NAME...'))
2575 def debugnamecomplete(ui, repo, *args):
2577 def debugnamecomplete(ui, repo, *args):
2576 '''complete "names" - tags, open branch names, bookmark names'''
2578 '''complete "names" - tags, open branch names, bookmark names'''
2577
2579
2578 names = set()
2580 names = set()
2579 # since we previously only listed open branches, we will handle that
2581 # since we previously only listed open branches, we will handle that
2580 # specially (after this for loop)
2582 # specially (after this for loop)
2581 for name, ns in repo.names.items():
2583 for name, ns in repo.names.items():
2582 if name != b'branches':
2584 if name != b'branches':
2583 names.update(ns.listnames(repo))
2585 names.update(ns.listnames(repo))
2584 names.update(
2586 names.update(
2585 tag
2587 tag
2586 for (tag, heads, tip, closed) in repo.branchmap().iterbranches()
2588 for (tag, heads, tip, closed) in repo.branchmap().iterbranches()
2587 if not closed
2589 if not closed
2588 )
2590 )
2589 completions = set()
2591 completions = set()
2590 if not args:
2592 if not args:
2591 args = [b'']
2593 args = [b'']
2592 for a in args:
2594 for a in args:
2593 completions.update(n for n in names if n.startswith(a))
2595 completions.update(n for n in names if n.startswith(a))
2594 ui.write(b'\n'.join(sorted(completions)))
2596 ui.write(b'\n'.join(sorted(completions)))
2595 ui.write(b'\n')
2597 ui.write(b'\n')
2596
2598
2597
2599
2598 @command(
2600 @command(
2599 b'debugnodemap',
2601 b'debugnodemap',
2600 [
2602 [
2601 (
2603 (
2602 b'',
2604 b'',
2603 b'dump-new',
2605 b'dump-new',
2604 False,
2606 False,
2605 _(b'write a (new) persistent binary nodemap on stdout'),
2607 _(b'write a (new) persistent binary nodemap on stdout'),
2606 ),
2608 ),
2607 (b'', b'dump-disk', False, _(b'dump on-disk data on stdout')),
2609 (b'', b'dump-disk', False, _(b'dump on-disk data on stdout')),
2608 (
2610 (
2609 b'',
2611 b'',
2610 b'check',
2612 b'check',
2611 False,
2613 False,
2612 _(b'check that the data on disk data are correct.'),
2614 _(b'check that the data on disk data are correct.'),
2613 ),
2615 ),
2614 (
2616 (
2615 b'',
2617 b'',
2616 b'metadata',
2618 b'metadata',
2617 False,
2619 False,
2618 _(b'display the on disk meta data for the nodemap'),
2620 _(b'display the on disk meta data for the nodemap'),
2619 ),
2621 ),
2620 ],
2622 ],
2621 )
2623 )
2622 def debugnodemap(ui, repo, **opts):
2624 def debugnodemap(ui, repo, **opts):
2623 """write and inspect on disk nodemap"""
2625 """write and inspect on disk nodemap"""
2624 if opts['dump_new']:
2626 if opts['dump_new']:
2625 unfi = repo.unfiltered()
2627 unfi = repo.unfiltered()
2626 cl = unfi.changelog
2628 cl = unfi.changelog
2627 if util.safehasattr(cl.index, "nodemap_data_all"):
2629 if util.safehasattr(cl.index, "nodemap_data_all"):
2628 data = cl.index.nodemap_data_all()
2630 data = cl.index.nodemap_data_all()
2629 else:
2631 else:
2630 data = nodemap.persistent_data(cl.index)
2632 data = nodemap.persistent_data(cl.index)
2631 ui.write(data)
2633 ui.write(data)
2632 elif opts['dump_disk']:
2634 elif opts['dump_disk']:
2633 unfi = repo.unfiltered()
2635 unfi = repo.unfiltered()
2634 cl = unfi.changelog
2636 cl = unfi.changelog
2635 nm_data = nodemap.persisted_data(cl)
2637 nm_data = nodemap.persisted_data(cl)
2636 if nm_data is not None:
2638 if nm_data is not None:
2637 docket, data = nm_data
2639 docket, data = nm_data
2638 ui.write(data[:])
2640 ui.write(data[:])
2639 elif opts['check']:
2641 elif opts['check']:
2640 unfi = repo.unfiltered()
2642 unfi = repo.unfiltered()
2641 cl = unfi.changelog
2643 cl = unfi.changelog
2642 nm_data = nodemap.persisted_data(cl)
2644 nm_data = nodemap.persisted_data(cl)
2643 if nm_data is not None:
2645 if nm_data is not None:
2644 docket, data = nm_data
2646 docket, data = nm_data
2645 return nodemap.check_data(ui, cl.index, data)
2647 return nodemap.check_data(ui, cl.index, data)
2646 elif opts['metadata']:
2648 elif opts['metadata']:
2647 unfi = repo.unfiltered()
2649 unfi = repo.unfiltered()
2648 cl = unfi.changelog
2650 cl = unfi.changelog
2649 nm_data = nodemap.persisted_data(cl)
2651 nm_data = nodemap.persisted_data(cl)
2650 if nm_data is not None:
2652 if nm_data is not None:
2651 docket, data = nm_data
2653 docket, data = nm_data
2652 ui.write((b"uid: %s\n") % docket.uid)
2654 ui.write((b"uid: %s\n") % docket.uid)
2653 ui.write((b"tip-rev: %d\n") % docket.tip_rev)
2655 ui.write((b"tip-rev: %d\n") % docket.tip_rev)
2654 ui.write((b"tip-node: %s\n") % hex(docket.tip_node))
2656 ui.write((b"tip-node: %s\n") % hex(docket.tip_node))
2655 ui.write((b"data-length: %d\n") % docket.data_length)
2657 ui.write((b"data-length: %d\n") % docket.data_length)
2656 ui.write((b"data-unused: %d\n") % docket.data_unused)
2658 ui.write((b"data-unused: %d\n") % docket.data_unused)
2657 unused_perc = docket.data_unused * 100.0 / docket.data_length
2659 unused_perc = docket.data_unused * 100.0 / docket.data_length
2658 ui.write((b"data-unused: %2.3f%%\n") % unused_perc)
2660 ui.write((b"data-unused: %2.3f%%\n") % unused_perc)
2659
2661
2660
2662
2661 @command(
2663 @command(
2662 b'debugobsolete',
2664 b'debugobsolete',
2663 [
2665 [
2664 (b'', b'flags', 0, _(b'markers flag')),
2666 (b'', b'flags', 0, _(b'markers flag')),
2665 (
2667 (
2666 b'',
2668 b'',
2667 b'record-parents',
2669 b'record-parents',
2668 False,
2670 False,
2669 _(b'record parent information for the precursor'),
2671 _(b'record parent information for the precursor'),
2670 ),
2672 ),
2671 (b'r', b'rev', [], _(b'display markers relevant to REV')),
2673 (b'r', b'rev', [], _(b'display markers relevant to REV')),
2672 (
2674 (
2673 b'',
2675 b'',
2674 b'exclusive',
2676 b'exclusive',
2675 False,
2677 False,
2676 _(b'restrict display to markers only relevant to REV'),
2678 _(b'restrict display to markers only relevant to REV'),
2677 ),
2679 ),
2678 (b'', b'index', False, _(b'display index of the marker')),
2680 (b'', b'index', False, _(b'display index of the marker')),
2679 (b'', b'delete', [], _(b'delete markers specified by indices')),
2681 (b'', b'delete', [], _(b'delete markers specified by indices')),
2680 ]
2682 ]
2681 + cmdutil.commitopts2
2683 + cmdutil.commitopts2
2682 + cmdutil.formatteropts,
2684 + cmdutil.formatteropts,
2683 _(b'[OBSOLETED [REPLACEMENT ...]]'),
2685 _(b'[OBSOLETED [REPLACEMENT ...]]'),
2684 )
2686 )
2685 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
2687 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
2686 """create arbitrary obsolete marker
2688 """create arbitrary obsolete marker
2687
2689
2688 With no arguments, displays the list of obsolescence markers."""
2690 With no arguments, displays the list of obsolescence markers."""
2689
2691
2690 opts = pycompat.byteskwargs(opts)
2692 opts = pycompat.byteskwargs(opts)
2691
2693
2692 def parsenodeid(s):
2694 def parsenodeid(s):
2693 try:
2695 try:
2694 # We do not use revsingle/revrange functions here to accept
2696 # We do not use revsingle/revrange functions here to accept
2695 # arbitrary node identifiers, possibly not present in the
2697 # arbitrary node identifiers, possibly not present in the
2696 # local repository.
2698 # local repository.
2697 n = bin(s)
2699 n = bin(s)
2698 if len(n) != repo.nodeconstants.nodelen:
2700 if len(n) != repo.nodeconstants.nodelen:
2699 raise ValueError
2701 raise ValueError
2700 return n
2702 return n
2701 except ValueError:
2703 except ValueError:
2702 raise error.InputError(
2704 raise error.InputError(
2703 b'changeset references must be full hexadecimal '
2705 b'changeset references must be full hexadecimal '
2704 b'node identifiers'
2706 b'node identifiers'
2705 )
2707 )
2706
2708
2707 if opts.get(b'delete'):
2709 if opts.get(b'delete'):
2708 indices = []
2710 indices = []
2709 for v in opts.get(b'delete'):
2711 for v in opts.get(b'delete'):
2710 try:
2712 try:
2711 indices.append(int(v))
2713 indices.append(int(v))
2712 except ValueError:
2714 except ValueError:
2713 raise error.InputError(
2715 raise error.InputError(
2714 _(b'invalid index value: %r') % v,
2716 _(b'invalid index value: %r') % v,
2715 hint=_(b'use integers for indices'),
2717 hint=_(b'use integers for indices'),
2716 )
2718 )
2717
2719
2718 if repo.currenttransaction():
2720 if repo.currenttransaction():
2719 raise error.Abort(
2721 raise error.Abort(
2720 _(b'cannot delete obsmarkers in the middle of transaction.')
2722 _(b'cannot delete obsmarkers in the middle of transaction.')
2721 )
2723 )
2722
2724
2723 with repo.lock():
2725 with repo.lock():
2724 n = repair.deleteobsmarkers(repo.obsstore, indices)
2726 n = repair.deleteobsmarkers(repo.obsstore, indices)
2725 ui.write(_(b'deleted %i obsolescence markers\n') % n)
2727 ui.write(_(b'deleted %i obsolescence markers\n') % n)
2726
2728
2727 return
2729 return
2728
2730
2729 if precursor is not None:
2731 if precursor is not None:
2730 if opts[b'rev']:
2732 if opts[b'rev']:
2731 raise error.InputError(
2733 raise error.InputError(
2732 b'cannot select revision when creating marker'
2734 b'cannot select revision when creating marker'
2733 )
2735 )
2734 metadata = {}
2736 metadata = {}
2735 metadata[b'user'] = encoding.fromlocal(opts[b'user'] or ui.username())
2737 metadata[b'user'] = encoding.fromlocal(opts[b'user'] or ui.username())
2736 succs = tuple(parsenodeid(succ) for succ in successors)
2738 succs = tuple(parsenodeid(succ) for succ in successors)
2737 l = repo.lock()
2739 l = repo.lock()
2738 try:
2740 try:
2739 tr = repo.transaction(b'debugobsolete')
2741 tr = repo.transaction(b'debugobsolete')
2740 try:
2742 try:
2741 date = opts.get(b'date')
2743 date = opts.get(b'date')
2742 if date:
2744 if date:
2743 date = dateutil.parsedate(date)
2745 date = dateutil.parsedate(date)
2744 else:
2746 else:
2745 date = None
2747 date = None
2746 prec = parsenodeid(precursor)
2748 prec = parsenodeid(precursor)
2747 parents = None
2749 parents = None
2748 if opts[b'record_parents']:
2750 if opts[b'record_parents']:
2749 if prec not in repo.unfiltered():
2751 if prec not in repo.unfiltered():
2750 raise error.Abort(
2752 raise error.Abort(
2751 b'cannot used --record-parents on '
2753 b'cannot used --record-parents on '
2752 b'unknown changesets'
2754 b'unknown changesets'
2753 )
2755 )
2754 parents = repo.unfiltered()[prec].parents()
2756 parents = repo.unfiltered()[prec].parents()
2755 parents = tuple(p.node() for p in parents)
2757 parents = tuple(p.node() for p in parents)
2756 repo.obsstore.create(
2758 repo.obsstore.create(
2757 tr,
2759 tr,
2758 prec,
2760 prec,
2759 succs,
2761 succs,
2760 opts[b'flags'],
2762 opts[b'flags'],
2761 parents=parents,
2763 parents=parents,
2762 date=date,
2764 date=date,
2763 metadata=metadata,
2765 metadata=metadata,
2764 ui=ui,
2766 ui=ui,
2765 )
2767 )
2766 tr.close()
2768 tr.close()
2767 except ValueError as exc:
2769 except ValueError as exc:
2768 raise error.Abort(
2770 raise error.Abort(
2769 _(b'bad obsmarker input: %s') % stringutil.forcebytestr(exc)
2771 _(b'bad obsmarker input: %s') % stringutil.forcebytestr(exc)
2770 )
2772 )
2771 finally:
2773 finally:
2772 tr.release()
2774 tr.release()
2773 finally:
2775 finally:
2774 l.release()
2776 l.release()
2775 else:
2777 else:
2776 if opts[b'rev']:
2778 if opts[b'rev']:
2777 revs = logcmdutil.revrange(repo, opts[b'rev'])
2779 revs = logcmdutil.revrange(repo, opts[b'rev'])
2778 nodes = [repo[r].node() for r in revs]
2780 nodes = [repo[r].node() for r in revs]
2779 markers = list(
2781 markers = list(
2780 obsutil.getmarkers(
2782 obsutil.getmarkers(
2781 repo, nodes=nodes, exclusive=opts[b'exclusive']
2783 repo, nodes=nodes, exclusive=opts[b'exclusive']
2782 )
2784 )
2783 )
2785 )
2784 markers.sort(key=lambda x: x._data)
2786 markers.sort(key=lambda x: x._data)
2785 else:
2787 else:
2786 markers = obsutil.getmarkers(repo)
2788 markers = obsutil.getmarkers(repo)
2787
2789
2788 markerstoiter = markers
2790 markerstoiter = markers
2789 isrelevant = lambda m: True
2791 isrelevant = lambda m: True
2790 if opts.get(b'rev') and opts.get(b'index'):
2792 if opts.get(b'rev') and opts.get(b'index'):
2791 markerstoiter = obsutil.getmarkers(repo)
2793 markerstoiter = obsutil.getmarkers(repo)
2792 markerset = set(markers)
2794 markerset = set(markers)
2793 isrelevant = lambda m: m in markerset
2795 isrelevant = lambda m: m in markerset
2794
2796
2795 fm = ui.formatter(b'debugobsolete', opts)
2797 fm = ui.formatter(b'debugobsolete', opts)
2796 for i, m in enumerate(markerstoiter):
2798 for i, m in enumerate(markerstoiter):
2797 if not isrelevant(m):
2799 if not isrelevant(m):
2798 # marker can be irrelevant when we're iterating over a set
2800 # marker can be irrelevant when we're iterating over a set
2799 # of markers (markerstoiter) which is bigger than the set
2801 # of markers (markerstoiter) which is bigger than the set
2800 # of markers we want to display (markers)
2802 # of markers we want to display (markers)
2801 # this can happen if both --index and --rev options are
2803 # this can happen if both --index and --rev options are
2802 # provided and thus we need to iterate over all of the markers
2804 # provided and thus we need to iterate over all of the markers
2803 # to get the correct indices, but only display the ones that
2805 # to get the correct indices, but only display the ones that
2804 # are relevant to --rev value
2806 # are relevant to --rev value
2805 continue
2807 continue
2806 fm.startitem()
2808 fm.startitem()
2807 ind = i if opts.get(b'index') else None
2809 ind = i if opts.get(b'index') else None
2808 cmdutil.showmarker(fm, m, index=ind)
2810 cmdutil.showmarker(fm, m, index=ind)
2809 fm.end()
2811 fm.end()
2810
2812
2811
2813
2812 @command(
2814 @command(
2813 b'debugp1copies',
2815 b'debugp1copies',
2814 [(b'r', b'rev', b'', _(b'revision to debug'), _(b'REV'))],
2816 [(b'r', b'rev', b'', _(b'revision to debug'), _(b'REV'))],
2815 _(b'[-r REV]'),
2817 _(b'[-r REV]'),
2816 )
2818 )
2817 def debugp1copies(ui, repo, **opts):
2819 def debugp1copies(ui, repo, **opts):
2818 """dump copy information compared to p1"""
2820 """dump copy information compared to p1"""
2819
2821
2820 opts = pycompat.byteskwargs(opts)
2822 opts = pycompat.byteskwargs(opts)
2821 ctx = scmutil.revsingle(repo, opts.get(b'rev'), default=None)
2823 ctx = scmutil.revsingle(repo, opts.get(b'rev'), default=None)
2822 for dst, src in ctx.p1copies().items():
2824 for dst, src in ctx.p1copies().items():
2823 ui.write(b'%s -> %s\n' % (src, dst))
2825 ui.write(b'%s -> %s\n' % (src, dst))
2824
2826
2825
2827
2826 @command(
2828 @command(
2827 b'debugp2copies',
2829 b'debugp2copies',
2828 [(b'r', b'rev', b'', _(b'revision to debug'), _(b'REV'))],
2830 [(b'r', b'rev', b'', _(b'revision to debug'), _(b'REV'))],
2829 _(b'[-r REV]'),
2831 _(b'[-r REV]'),
2830 )
2832 )
2831 def debugp2copies(ui, repo, **opts):
2833 def debugp2copies(ui, repo, **opts):
2832 """dump copy information compared to p2"""
2834 """dump copy information compared to p2"""
2833
2835
2834 opts = pycompat.byteskwargs(opts)
2836 opts = pycompat.byteskwargs(opts)
2835 ctx = scmutil.revsingle(repo, opts.get(b'rev'), default=None)
2837 ctx = scmutil.revsingle(repo, opts.get(b'rev'), default=None)
2836 for dst, src in ctx.p2copies().items():
2838 for dst, src in ctx.p2copies().items():
2837 ui.write(b'%s -> %s\n' % (src, dst))
2839 ui.write(b'%s -> %s\n' % (src, dst))
2838
2840
2839
2841
2840 @command(
2842 @command(
2841 b'debugpathcomplete',
2843 b'debugpathcomplete',
2842 [
2844 [
2843 (b'f', b'full', None, _(b'complete an entire path')),
2845 (b'f', b'full', None, _(b'complete an entire path')),
2844 (b'n', b'normal', None, _(b'show only normal files')),
2846 (b'n', b'normal', None, _(b'show only normal files')),
2845 (b'a', b'added', None, _(b'show only added files')),
2847 (b'a', b'added', None, _(b'show only added files')),
2846 (b'r', b'removed', None, _(b'show only removed files')),
2848 (b'r', b'removed', None, _(b'show only removed files')),
2847 ],
2849 ],
2848 _(b'FILESPEC...'),
2850 _(b'FILESPEC...'),
2849 )
2851 )
2850 def debugpathcomplete(ui, repo, *specs, **opts):
2852 def debugpathcomplete(ui, repo, *specs, **opts):
2851 """complete part or all of a tracked path
2853 """complete part or all of a tracked path
2852
2854
2853 This command supports shells that offer path name completion. It
2855 This command supports shells that offer path name completion. It
2854 currently completes only files already known to the dirstate.
2856 currently completes only files already known to the dirstate.
2855
2857
2856 Completion extends only to the next path segment unless
2858 Completion extends only to the next path segment unless
2857 --full is specified, in which case entire paths are used."""
2859 --full is specified, in which case entire paths are used."""
2858
2860
2859 def complete(path, acceptable):
2861 def complete(path, acceptable):
2860 dirstate = repo.dirstate
2862 dirstate = repo.dirstate
2861 spec = os.path.normpath(os.path.join(encoding.getcwd(), path))
2863 spec = os.path.normpath(os.path.join(encoding.getcwd(), path))
2862 rootdir = repo.root + pycompat.ossep
2864 rootdir = repo.root + pycompat.ossep
2863 if spec != repo.root and not spec.startswith(rootdir):
2865 if spec != repo.root and not spec.startswith(rootdir):
2864 return [], []
2866 return [], []
2865 if os.path.isdir(spec):
2867 if os.path.isdir(spec):
2866 spec += b'/'
2868 spec += b'/'
2867 spec = spec[len(rootdir) :]
2869 spec = spec[len(rootdir) :]
2868 fixpaths = pycompat.ossep != b'/'
2870 fixpaths = pycompat.ossep != b'/'
2869 if fixpaths:
2871 if fixpaths:
2870 spec = spec.replace(pycompat.ossep, b'/')
2872 spec = spec.replace(pycompat.ossep, b'/')
2871 speclen = len(spec)
2873 speclen = len(spec)
2872 fullpaths = opts['full']
2874 fullpaths = opts['full']
2873 files, dirs = set(), set()
2875 files, dirs = set(), set()
2874 adddir, addfile = dirs.add, files.add
2876 adddir, addfile = dirs.add, files.add
2875 for f, st in dirstate.items():
2877 for f, st in dirstate.items():
2876 if f.startswith(spec) and st.state in acceptable:
2878 if f.startswith(spec) and st.state in acceptable:
2877 if fixpaths:
2879 if fixpaths:
2878 f = f.replace(b'/', pycompat.ossep)
2880 f = f.replace(b'/', pycompat.ossep)
2879 if fullpaths:
2881 if fullpaths:
2880 addfile(f)
2882 addfile(f)
2881 continue
2883 continue
2882 s = f.find(pycompat.ossep, speclen)
2884 s = f.find(pycompat.ossep, speclen)
2883 if s >= 0:
2885 if s >= 0:
2884 adddir(f[:s])
2886 adddir(f[:s])
2885 else:
2887 else:
2886 addfile(f)
2888 addfile(f)
2887 return files, dirs
2889 return files, dirs
2888
2890
2889 acceptable = b''
2891 acceptable = b''
2890 if opts['normal']:
2892 if opts['normal']:
2891 acceptable += b'nm'
2893 acceptable += b'nm'
2892 if opts['added']:
2894 if opts['added']:
2893 acceptable += b'a'
2895 acceptable += b'a'
2894 if opts['removed']:
2896 if opts['removed']:
2895 acceptable += b'r'
2897 acceptable += b'r'
2896 cwd = repo.getcwd()
2898 cwd = repo.getcwd()
2897 if not specs:
2899 if not specs:
2898 specs = [b'.']
2900 specs = [b'.']
2899
2901
2900 files, dirs = set(), set()
2902 files, dirs = set(), set()
2901 for spec in specs:
2903 for spec in specs:
2902 f, d = complete(spec, acceptable or b'nmar')
2904 f, d = complete(spec, acceptable or b'nmar')
2903 files.update(f)
2905 files.update(f)
2904 dirs.update(d)
2906 dirs.update(d)
2905 files.update(dirs)
2907 files.update(dirs)
2906 ui.write(b'\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
2908 ui.write(b'\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
2907 ui.write(b'\n')
2909 ui.write(b'\n')
2908
2910
2909
2911
2910 @command(
2912 @command(
2911 b'debugpathcopies',
2913 b'debugpathcopies',
2912 cmdutil.walkopts,
2914 cmdutil.walkopts,
2913 b'hg debugpathcopies REV1 REV2 [FILE]',
2915 b'hg debugpathcopies REV1 REV2 [FILE]',
2914 inferrepo=True,
2916 inferrepo=True,
2915 )
2917 )
2916 def debugpathcopies(ui, repo, rev1, rev2, *pats, **opts):
2918 def debugpathcopies(ui, repo, rev1, rev2, *pats, **opts):
2917 """show copies between two revisions"""
2919 """show copies between two revisions"""
2918 ctx1 = scmutil.revsingle(repo, rev1)
2920 ctx1 = scmutil.revsingle(repo, rev1)
2919 ctx2 = scmutil.revsingle(repo, rev2)
2921 ctx2 = scmutil.revsingle(repo, rev2)
2920 m = scmutil.match(ctx1, pats, opts)
2922 m = scmutil.match(ctx1, pats, opts)
2921 for dst, src in sorted(copies.pathcopies(ctx1, ctx2, m).items()):
2923 for dst, src in sorted(copies.pathcopies(ctx1, ctx2, m).items()):
2922 ui.write(b'%s -> %s\n' % (src, dst))
2924 ui.write(b'%s -> %s\n' % (src, dst))
2923
2925
2924
2926
2925 @command(b'debugpeer', [], _(b'PATH'), norepo=True)
2927 @command(b'debugpeer', [], _(b'PATH'), norepo=True)
2926 def debugpeer(ui, path):
2928 def debugpeer(ui, path):
2927 """establish a connection to a peer repository"""
2929 """establish a connection to a peer repository"""
2928 # Always enable peer request logging. Requires --debug to display
2930 # Always enable peer request logging. Requires --debug to display
2929 # though.
2931 # though.
2930 overrides = {
2932 overrides = {
2931 (b'devel', b'debug.peer-request'): True,
2933 (b'devel', b'debug.peer-request'): True,
2932 }
2934 }
2933
2935
2934 with ui.configoverride(overrides):
2936 with ui.configoverride(overrides):
2935 peer = hg.peer(ui, {}, path)
2937 peer = hg.peer(ui, {}, path)
2936
2938
2937 try:
2939 try:
2938 local = peer.local() is not None
2940 local = peer.local() is not None
2939 canpush = peer.canpush()
2941 canpush = peer.canpush()
2940
2942
2941 ui.write(_(b'url: %s\n') % peer.url())
2943 ui.write(_(b'url: %s\n') % peer.url())
2942 ui.write(_(b'local: %s\n') % (_(b'yes') if local else _(b'no')))
2944 ui.write(_(b'local: %s\n') % (_(b'yes') if local else _(b'no')))
2943 ui.write(
2945 ui.write(
2944 _(b'pushable: %s\n') % (_(b'yes') if canpush else _(b'no'))
2946 _(b'pushable: %s\n') % (_(b'yes') if canpush else _(b'no'))
2945 )
2947 )
2946 finally:
2948 finally:
2947 peer.close()
2949 peer.close()
2948
2950
2949
2951
2950 @command(
2952 @command(
2951 b'debugpickmergetool',
2953 b'debugpickmergetool',
2952 [
2954 [
2953 (b'r', b'rev', b'', _(b'check for files in this revision'), _(b'REV')),
2955 (b'r', b'rev', b'', _(b'check for files in this revision'), _(b'REV')),
2954 (b'', b'changedelete', None, _(b'emulate merging change and delete')),
2956 (b'', b'changedelete', None, _(b'emulate merging change and delete')),
2955 ]
2957 ]
2956 + cmdutil.walkopts
2958 + cmdutil.walkopts
2957 + cmdutil.mergetoolopts,
2959 + cmdutil.mergetoolopts,
2958 _(b'[PATTERN]...'),
2960 _(b'[PATTERN]...'),
2959 inferrepo=True,
2961 inferrepo=True,
2960 )
2962 )
2961 def debugpickmergetool(ui, repo, *pats, **opts):
2963 def debugpickmergetool(ui, repo, *pats, **opts):
2962 """examine which merge tool is chosen for specified file
2964 """examine which merge tool is chosen for specified file
2963
2965
2964 As described in :hg:`help merge-tools`, Mercurial examines
2966 As described in :hg:`help merge-tools`, Mercurial examines
2965 configurations below in this order to decide which merge tool is
2967 configurations below in this order to decide which merge tool is
2966 chosen for specified file.
2968 chosen for specified file.
2967
2969
2968 1. ``--tool`` option
2970 1. ``--tool`` option
2969 2. ``HGMERGE`` environment variable
2971 2. ``HGMERGE`` environment variable
2970 3. configurations in ``merge-patterns`` section
2972 3. configurations in ``merge-patterns`` section
2971 4. configuration of ``ui.merge``
2973 4. configuration of ``ui.merge``
2972 5. configurations in ``merge-tools`` section
2974 5. configurations in ``merge-tools`` section
2973 6. ``hgmerge`` tool (for historical reason only)
2975 6. ``hgmerge`` tool (for historical reason only)
2974 7. default tool for fallback (``:merge`` or ``:prompt``)
2976 7. default tool for fallback (``:merge`` or ``:prompt``)
2975
2977
2976 This command writes out examination result in the style below::
2978 This command writes out examination result in the style below::
2977
2979
2978 FILE = MERGETOOL
2980 FILE = MERGETOOL
2979
2981
2980 By default, all files known in the first parent context of the
2982 By default, all files known in the first parent context of the
2981 working directory are examined. Use file patterns and/or -I/-X
2983 working directory are examined. Use file patterns and/or -I/-X
2982 options to limit target files. -r/--rev is also useful to examine
2984 options to limit target files. -r/--rev is also useful to examine
2983 files in another context without actual updating to it.
2985 files in another context without actual updating to it.
2984
2986
2985 With --debug, this command shows warning messages while matching
2987 With --debug, this command shows warning messages while matching
2986 against ``merge-patterns`` and so on, too. It is recommended to
2988 against ``merge-patterns`` and so on, too. It is recommended to
2987 use this option with explicit file patterns and/or -I/-X options,
2989 use this option with explicit file patterns and/or -I/-X options,
2988 because this option increases amount of output per file according
2990 because this option increases amount of output per file according
2989 to configurations in hgrc.
2991 to configurations in hgrc.
2990
2992
2991 With -v/--verbose, this command shows configurations below at
2993 With -v/--verbose, this command shows configurations below at
2992 first (only if specified).
2994 first (only if specified).
2993
2995
2994 - ``--tool`` option
2996 - ``--tool`` option
2995 - ``HGMERGE`` environment variable
2997 - ``HGMERGE`` environment variable
2996 - configuration of ``ui.merge``
2998 - configuration of ``ui.merge``
2997
2999
2998 If merge tool is chosen before matching against
3000 If merge tool is chosen before matching against
2999 ``merge-patterns``, this command can't show any helpful
3001 ``merge-patterns``, this command can't show any helpful
3000 information, even with --debug. In such case, information above is
3002 information, even with --debug. In such case, information above is
3001 useful to know why a merge tool is chosen.
3003 useful to know why a merge tool is chosen.
3002 """
3004 """
3003 opts = pycompat.byteskwargs(opts)
3005 opts = pycompat.byteskwargs(opts)
3004 overrides = {}
3006 overrides = {}
3005 if opts[b'tool']:
3007 if opts[b'tool']:
3006 overrides[(b'ui', b'forcemerge')] = opts[b'tool']
3008 overrides[(b'ui', b'forcemerge')] = opts[b'tool']
3007 ui.notenoi18n(b'with --tool %r\n' % (pycompat.bytestr(opts[b'tool'])))
3009 ui.notenoi18n(b'with --tool %r\n' % (pycompat.bytestr(opts[b'tool'])))
3008
3010
3009 with ui.configoverride(overrides, b'debugmergepatterns'):
3011 with ui.configoverride(overrides, b'debugmergepatterns'):
3010 hgmerge = encoding.environ.get(b"HGMERGE")
3012 hgmerge = encoding.environ.get(b"HGMERGE")
3011 if hgmerge is not None:
3013 if hgmerge is not None:
3012 ui.notenoi18n(b'with HGMERGE=%r\n' % (pycompat.bytestr(hgmerge)))
3014 ui.notenoi18n(b'with HGMERGE=%r\n' % (pycompat.bytestr(hgmerge)))
3013 uimerge = ui.config(b"ui", b"merge")
3015 uimerge = ui.config(b"ui", b"merge")
3014 if uimerge:
3016 if uimerge:
3015 ui.notenoi18n(b'with ui.merge=%r\n' % (pycompat.bytestr(uimerge)))
3017 ui.notenoi18n(b'with ui.merge=%r\n' % (pycompat.bytestr(uimerge)))
3016
3018
3017 ctx = scmutil.revsingle(repo, opts.get(b'rev'))
3019 ctx = scmutil.revsingle(repo, opts.get(b'rev'))
3018 m = scmutil.match(ctx, pats, opts)
3020 m = scmutil.match(ctx, pats, opts)
3019 changedelete = opts[b'changedelete']
3021 changedelete = opts[b'changedelete']
3020 for path in ctx.walk(m):
3022 for path in ctx.walk(m):
3021 fctx = ctx[path]
3023 fctx = ctx[path]
3022 with ui.silent(
3024 with ui.silent(
3023 error=True
3025 error=True
3024 ) if not ui.debugflag else util.nullcontextmanager():
3026 ) if not ui.debugflag else util.nullcontextmanager():
3025 tool, toolpath = filemerge._picktool(
3027 tool, toolpath = filemerge._picktool(
3026 repo,
3028 repo,
3027 ui,
3029 ui,
3028 path,
3030 path,
3029 fctx.isbinary(),
3031 fctx.isbinary(),
3030 b'l' in fctx.flags(),
3032 b'l' in fctx.flags(),
3031 changedelete,
3033 changedelete,
3032 )
3034 )
3033 ui.write(b'%s = %s\n' % (path, tool))
3035 ui.write(b'%s = %s\n' % (path, tool))
3034
3036
3035
3037
3036 @command(b'debugpushkey', [], _(b'REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
3038 @command(b'debugpushkey', [], _(b'REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
3037 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
3039 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
3038 """access the pushkey key/value protocol
3040 """access the pushkey key/value protocol
3039
3041
3040 With two args, list the keys in the given namespace.
3042 With two args, list the keys in the given namespace.
3041
3043
3042 With five args, set a key to new if it currently is set to old.
3044 With five args, set a key to new if it currently is set to old.
3043 Reports success or failure.
3045 Reports success or failure.
3044 """
3046 """
3045
3047
3046 target = hg.peer(ui, {}, repopath)
3048 target = hg.peer(ui, {}, repopath)
3047 try:
3049 try:
3048 if keyinfo:
3050 if keyinfo:
3049 key, old, new = keyinfo
3051 key, old, new = keyinfo
3050 with target.commandexecutor() as e:
3052 with target.commandexecutor() as e:
3051 r = e.callcommand(
3053 r = e.callcommand(
3052 b'pushkey',
3054 b'pushkey',
3053 {
3055 {
3054 b'namespace': namespace,
3056 b'namespace': namespace,
3055 b'key': key,
3057 b'key': key,
3056 b'old': old,
3058 b'old': old,
3057 b'new': new,
3059 b'new': new,
3058 },
3060 },
3059 ).result()
3061 ).result()
3060
3062
3061 ui.status(pycompat.bytestr(r) + b'\n')
3063 ui.status(pycompat.bytestr(r) + b'\n')
3062 return not r
3064 return not r
3063 else:
3065 else:
3064 for k, v in sorted(target.listkeys(namespace).items()):
3066 for k, v in sorted(target.listkeys(namespace).items()):
3065 ui.write(
3067 ui.write(
3066 b"%s\t%s\n"
3068 b"%s\t%s\n"
3067 % (stringutil.escapestr(k), stringutil.escapestr(v))
3069 % (stringutil.escapestr(k), stringutil.escapestr(v))
3068 )
3070 )
3069 finally:
3071 finally:
3070 target.close()
3072 target.close()
3071
3073
3072
3074
3073 @command(b'debugpvec', [], _(b'A B'))
3075 @command(b'debugpvec', [], _(b'A B'))
3074 def debugpvec(ui, repo, a, b=None):
3076 def debugpvec(ui, repo, a, b=None):
3075 ca = scmutil.revsingle(repo, a)
3077 ca = scmutil.revsingle(repo, a)
3076 cb = scmutil.revsingle(repo, b)
3078 cb = scmutil.revsingle(repo, b)
3077 pa = pvec.ctxpvec(ca)
3079 pa = pvec.ctxpvec(ca)
3078 pb = pvec.ctxpvec(cb)
3080 pb = pvec.ctxpvec(cb)
3079 if pa == pb:
3081 if pa == pb:
3080 rel = b"="
3082 rel = b"="
3081 elif pa > pb:
3083 elif pa > pb:
3082 rel = b">"
3084 rel = b">"
3083 elif pa < pb:
3085 elif pa < pb:
3084 rel = b"<"
3086 rel = b"<"
3085 elif pa | pb:
3087 elif pa | pb:
3086 rel = b"|"
3088 rel = b"|"
3087 ui.write(_(b"a: %s\n") % pa)
3089 ui.write(_(b"a: %s\n") % pa)
3088 ui.write(_(b"b: %s\n") % pb)
3090 ui.write(_(b"b: %s\n") % pb)
3089 ui.write(_(b"depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
3091 ui.write(_(b"depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
3090 ui.write(
3092 ui.write(
3091 _(b"delta: %d hdist: %d distance: %d relation: %s\n")
3093 _(b"delta: %d hdist: %d distance: %d relation: %s\n")
3092 % (
3094 % (
3093 abs(pa._depth - pb._depth),
3095 abs(pa._depth - pb._depth),
3094 pvec._hamming(pa._vec, pb._vec),
3096 pvec._hamming(pa._vec, pb._vec),
3095 pa.distance(pb),
3097 pa.distance(pb),
3096 rel,
3098 rel,
3097 )
3099 )
3098 )
3100 )
3099
3101
3100
3102
3101 @command(
3103 @command(
3102 b'debugrebuilddirstate|debugrebuildstate',
3104 b'debugrebuilddirstate|debugrebuildstate',
3103 [
3105 [
3104 (b'r', b'rev', b'', _(b'revision to rebuild to'), _(b'REV')),
3106 (b'r', b'rev', b'', _(b'revision to rebuild to'), _(b'REV')),
3105 (
3107 (
3106 b'',
3108 b'',
3107 b'minimal',
3109 b'minimal',
3108 None,
3110 None,
3109 _(
3111 _(
3110 b'only rebuild files that are inconsistent with '
3112 b'only rebuild files that are inconsistent with '
3111 b'the working copy parent'
3113 b'the working copy parent'
3112 ),
3114 ),
3113 ),
3115 ),
3114 ],
3116 ],
3115 _(b'[-r REV]'),
3117 _(b'[-r REV]'),
3116 )
3118 )
3117 def debugrebuilddirstate(ui, repo, rev, **opts):
3119 def debugrebuilddirstate(ui, repo, rev, **opts):
3118 """rebuild the dirstate as it would look like for the given revision
3120 """rebuild the dirstate as it would look like for the given revision
3119
3121
3120 If no revision is specified the first current parent will be used.
3122 If no revision is specified the first current parent will be used.
3121
3123
3122 The dirstate will be set to the files of the given revision.
3124 The dirstate will be set to the files of the given revision.
3123 The actual working directory content or existing dirstate
3125 The actual working directory content or existing dirstate
3124 information such as adds or removes is not considered.
3126 information such as adds or removes is not considered.
3125
3127
3126 ``minimal`` will only rebuild the dirstate status for files that claim to be
3128 ``minimal`` will only rebuild the dirstate status for files that claim to be
3127 tracked but are not in the parent manifest, or that exist in the parent
3129 tracked but are not in the parent manifest, or that exist in the parent
3128 manifest but are not in the dirstate. It will not change adds, removes, or
3130 manifest but are not in the dirstate. It will not change adds, removes, or
3129 modified files that are in the working copy parent.
3131 modified files that are in the working copy parent.
3130
3132
3131 One use of this command is to make the next :hg:`status` invocation
3133 One use of this command is to make the next :hg:`status` invocation
3132 check the actual file content.
3134 check the actual file content.
3133 """
3135 """
3134 ctx = scmutil.revsingle(repo, rev)
3136 ctx = scmutil.revsingle(repo, rev)
3135 with repo.wlock():
3137 with repo.wlock():
3136 dirstate = repo.dirstate
3138 dirstate = repo.dirstate
3137 changedfiles = None
3139 changedfiles = None
3138 # See command doc for what minimal does.
3140 # See command doc for what minimal does.
3139 if opts.get('minimal'):
3141 if opts.get('minimal'):
3140 manifestfiles = set(ctx.manifest().keys())
3142 manifestfiles = set(ctx.manifest().keys())
3141 dirstatefiles = set(dirstate)
3143 dirstatefiles = set(dirstate)
3142 manifestonly = manifestfiles - dirstatefiles
3144 manifestonly = manifestfiles - dirstatefiles
3143 dsonly = dirstatefiles - manifestfiles
3145 dsonly = dirstatefiles - manifestfiles
3144 dsnotadded = {f for f in dsonly if not dirstate.get_entry(f).added}
3146 dsnotadded = {f for f in dsonly if not dirstate.get_entry(f).added}
3145 changedfiles = manifestonly | dsnotadded
3147 changedfiles = manifestonly | dsnotadded
3146
3148
3147 dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
3149 dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
3148
3150
3149
3151
3150 @command(
3152 @command(
3151 b'debugrebuildfncache',
3153 b'debugrebuildfncache',
3152 [
3154 [
3153 (
3155 (
3154 b'',
3156 b'',
3155 b'only-data',
3157 b'only-data',
3156 False,
3158 False,
3157 _(b'only look for wrong .d files (much faster)'),
3159 _(b'only look for wrong .d files (much faster)'),
3158 )
3160 )
3159 ],
3161 ],
3160 b'',
3162 b'',
3161 )
3163 )
3162 def debugrebuildfncache(ui, repo, **opts):
3164 def debugrebuildfncache(ui, repo, **opts):
3163 """rebuild the fncache file"""
3165 """rebuild the fncache file"""
3164 opts = pycompat.byteskwargs(opts)
3166 opts = pycompat.byteskwargs(opts)
3165 repair.rebuildfncache(ui, repo, opts.get(b"only_data"))
3167 repair.rebuildfncache(ui, repo, opts.get(b"only_data"))
3166
3168
3167
3169
3168 @command(
3170 @command(
3169 b'debugrename',
3171 b'debugrename',
3170 [(b'r', b'rev', b'', _(b'revision to debug'), _(b'REV'))],
3172 [(b'r', b'rev', b'', _(b'revision to debug'), _(b'REV'))],
3171 _(b'[-r REV] [FILE]...'),
3173 _(b'[-r REV] [FILE]...'),
3172 )
3174 )
3173 def debugrename(ui, repo, *pats, **opts):
3175 def debugrename(ui, repo, *pats, **opts):
3174 """dump rename information"""
3176 """dump rename information"""
3175
3177
3176 opts = pycompat.byteskwargs(opts)
3178 opts = pycompat.byteskwargs(opts)
3177 ctx = scmutil.revsingle(repo, opts.get(b'rev'))
3179 ctx = scmutil.revsingle(repo, opts.get(b'rev'))
3178 m = scmutil.match(ctx, pats, opts)
3180 m = scmutil.match(ctx, pats, opts)
3179 for abs in ctx.walk(m):
3181 for abs in ctx.walk(m):
3180 fctx = ctx[abs]
3182 fctx = ctx[abs]
3181 o = fctx.filelog().renamed(fctx.filenode())
3183 o = fctx.filelog().renamed(fctx.filenode())
3182 rel = repo.pathto(abs)
3184 rel = repo.pathto(abs)
3183 if o:
3185 if o:
3184 ui.write(_(b"%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
3186 ui.write(_(b"%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
3185 else:
3187 else:
3186 ui.write(_(b"%s not renamed\n") % rel)
3188 ui.write(_(b"%s not renamed\n") % rel)
3187
3189
3188
3190
3189 @command(b'debugrequires|debugrequirements', [], b'')
3191 @command(b'debugrequires|debugrequirements', [], b'')
3190 def debugrequirements(ui, repo):
3192 def debugrequirements(ui, repo):
3191 """print the current repo requirements"""
3193 """print the current repo requirements"""
3192 for r in sorted(repo.requirements):
3194 for r in sorted(repo.requirements):
3193 ui.write(b"%s\n" % r)
3195 ui.write(b"%s\n" % r)
3194
3196
3195
3197
3196 @command(
3198 @command(
3197 b'debugrevlog',
3199 b'debugrevlog',
3198 cmdutil.debugrevlogopts + [(b'd', b'dump', False, _(b'dump index data'))],
3200 cmdutil.debugrevlogopts + [(b'd', b'dump', False, _(b'dump index data'))],
3199 _(b'-c|-m|FILE'),
3201 _(b'-c|-m|FILE'),
3200 optionalrepo=True,
3202 optionalrepo=True,
3201 )
3203 )
3202 def debugrevlog(ui, repo, file_=None, **opts):
3204 def debugrevlog(ui, repo, file_=None, **opts):
3203 """show data and statistics about a revlog"""
3205 """show data and statistics about a revlog"""
3204 opts = pycompat.byteskwargs(opts)
3206 opts = pycompat.byteskwargs(opts)
3205 r = cmdutil.openrevlog(repo, b'debugrevlog', file_, opts)
3207 r = cmdutil.openrevlog(repo, b'debugrevlog', file_, opts)
3206
3208
3207 if opts.get(b"dump"):
3209 if opts.get(b"dump"):
3208 numrevs = len(r)
3210 numrevs = len(r)
3209 ui.write(
3211 ui.write(
3210 (
3212 (
3211 b"# rev p1rev p2rev start end deltastart base p1 p2"
3213 b"# rev p1rev p2rev start end deltastart base p1 p2"
3212 b" rawsize totalsize compression heads chainlen\n"
3214 b" rawsize totalsize compression heads chainlen\n"
3213 )
3215 )
3214 )
3216 )
3215 ts = 0
3217 ts = 0
3216 heads = set()
3218 heads = set()
3217
3219
3218 for rev in range(numrevs):
3220 for rev in range(numrevs):
3219 dbase = r.deltaparent(rev)
3221 dbase = r.deltaparent(rev)
3220 if dbase == -1:
3222 if dbase == -1:
3221 dbase = rev
3223 dbase = rev
3222 cbase = r.chainbase(rev)
3224 cbase = r.chainbase(rev)
3223 clen = r.chainlen(rev)
3225 clen = r.chainlen(rev)
3224 p1, p2 = r.parentrevs(rev)
3226 p1, p2 = r.parentrevs(rev)
3225 rs = r.rawsize(rev)
3227 rs = r.rawsize(rev)
3226 ts = ts + rs
3228 ts = ts + rs
3227 heads -= set(r.parentrevs(rev))
3229 heads -= set(r.parentrevs(rev))
3228 heads.add(rev)
3230 heads.add(rev)
3229 try:
3231 try:
3230 compression = ts / r.end(rev)
3232 compression = ts / r.end(rev)
3231 except ZeroDivisionError:
3233 except ZeroDivisionError:
3232 compression = 0
3234 compression = 0
3233 ui.write(
3235 ui.write(
3234 b"%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
3236 b"%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
3235 b"%11d %5d %8d\n"
3237 b"%11d %5d %8d\n"
3236 % (
3238 % (
3237 rev,
3239 rev,
3238 p1,
3240 p1,
3239 p2,
3241 p2,
3240 r.start(rev),
3242 r.start(rev),
3241 r.end(rev),
3243 r.end(rev),
3242 r.start(dbase),
3244 r.start(dbase),
3243 r.start(cbase),
3245 r.start(cbase),
3244 r.start(p1),
3246 r.start(p1),
3245 r.start(p2),
3247 r.start(p2),
3246 rs,
3248 rs,
3247 ts,
3249 ts,
3248 compression,
3250 compression,
3249 len(heads),
3251 len(heads),
3250 clen,
3252 clen,
3251 )
3253 )
3252 )
3254 )
3253 return 0
3255 return 0
3254
3256
3255 format = r._format_version
3257 format = r._format_version
3256 v = r._format_flags
3258 v = r._format_flags
3257 flags = []
3259 flags = []
3258 gdelta = False
3260 gdelta = False
3259 if v & revlog.FLAG_INLINE_DATA:
3261 if v & revlog.FLAG_INLINE_DATA:
3260 flags.append(b'inline')
3262 flags.append(b'inline')
3261 if v & revlog.FLAG_GENERALDELTA:
3263 if v & revlog.FLAG_GENERALDELTA:
3262 gdelta = True
3264 gdelta = True
3263 flags.append(b'generaldelta')
3265 flags.append(b'generaldelta')
3264 if not flags:
3266 if not flags:
3265 flags = [b'(none)']
3267 flags = [b'(none)']
3266
3268
3267 ### tracks merge vs single parent
3269 ### tracks merge vs single parent
3268 nummerges = 0
3270 nummerges = 0
3269
3271
3270 ### tracks ways the "delta" are build
3272 ### tracks ways the "delta" are build
3271 # nodelta
3273 # nodelta
3272 numempty = 0
3274 numempty = 0
3273 numemptytext = 0
3275 numemptytext = 0
3274 numemptydelta = 0
3276 numemptydelta = 0
3275 # full file content
3277 # full file content
3276 numfull = 0
3278 numfull = 0
3277 # intermediate snapshot against a prior snapshot
3279 # intermediate snapshot against a prior snapshot
3278 numsemi = 0
3280 numsemi = 0
3279 # snapshot count per depth
3281 # snapshot count per depth
3280 numsnapdepth = collections.defaultdict(lambda: 0)
3282 numsnapdepth = collections.defaultdict(lambda: 0)
3281 # delta against previous revision
3283 # delta against previous revision
3282 numprev = 0
3284 numprev = 0
3283 # delta against first or second parent (not prev)
3285 # delta against first or second parent (not prev)
3284 nump1 = 0
3286 nump1 = 0
3285 nump2 = 0
3287 nump2 = 0
3286 # delta against neither prev nor parents
3288 # delta against neither prev nor parents
3287 numother = 0
3289 numother = 0
3288 # delta against prev that are also first or second parent
3290 # delta against prev that are also first or second parent
3289 # (details of `numprev`)
3291 # (details of `numprev`)
3290 nump1prev = 0
3292 nump1prev = 0
3291 nump2prev = 0
3293 nump2prev = 0
3292
3294
3293 # data about delta chain of each revs
3295 # data about delta chain of each revs
3294 chainlengths = []
3296 chainlengths = []
3295 chainbases = []
3297 chainbases = []
3296 chainspans = []
3298 chainspans = []
3297
3299
3298 # data about each revision
3300 # data about each revision
3299 datasize = [None, 0, 0]
3301 datasize = [None, 0, 0]
3300 fullsize = [None, 0, 0]
3302 fullsize = [None, 0, 0]
3301 semisize = [None, 0, 0]
3303 semisize = [None, 0, 0]
3302 # snapshot count per depth
3304 # snapshot count per depth
3303 snapsizedepth = collections.defaultdict(lambda: [None, 0, 0])
3305 snapsizedepth = collections.defaultdict(lambda: [None, 0, 0])
3304 deltasize = [None, 0, 0]
3306 deltasize = [None, 0, 0]
3305 chunktypecounts = {}
3307 chunktypecounts = {}
3306 chunktypesizes = {}
3308 chunktypesizes = {}
3307
3309
3308 def addsize(size, l):
3310 def addsize(size, l):
3309 if l[0] is None or size < l[0]:
3311 if l[0] is None or size < l[0]:
3310 l[0] = size
3312 l[0] = size
3311 if size > l[1]:
3313 if size > l[1]:
3312 l[1] = size
3314 l[1] = size
3313 l[2] += size
3315 l[2] += size
3314
3316
3315 numrevs = len(r)
3317 numrevs = len(r)
3316 for rev in range(numrevs):
3318 for rev in range(numrevs):
3317 p1, p2 = r.parentrevs(rev)
3319 p1, p2 = r.parentrevs(rev)
3318 delta = r.deltaparent(rev)
3320 delta = r.deltaparent(rev)
3319 if format > 0:
3321 if format > 0:
3320 addsize(r.rawsize(rev), datasize)
3322 addsize(r.rawsize(rev), datasize)
3321 if p2 != nullrev:
3323 if p2 != nullrev:
3322 nummerges += 1
3324 nummerges += 1
3323 size = r.length(rev)
3325 size = r.length(rev)
3324 if delta == nullrev:
3326 if delta == nullrev:
3325 chainlengths.append(0)
3327 chainlengths.append(0)
3326 chainbases.append(r.start(rev))
3328 chainbases.append(r.start(rev))
3327 chainspans.append(size)
3329 chainspans.append(size)
3328 if size == 0:
3330 if size == 0:
3329 numempty += 1
3331 numempty += 1
3330 numemptytext += 1
3332 numemptytext += 1
3331 else:
3333 else:
3332 numfull += 1
3334 numfull += 1
3333 numsnapdepth[0] += 1
3335 numsnapdepth[0] += 1
3334 addsize(size, fullsize)
3336 addsize(size, fullsize)
3335 addsize(size, snapsizedepth[0])
3337 addsize(size, snapsizedepth[0])
3336 else:
3338 else:
3337 chainlengths.append(chainlengths[delta] + 1)
3339 chainlengths.append(chainlengths[delta] + 1)
3338 baseaddr = chainbases[delta]
3340 baseaddr = chainbases[delta]
3339 revaddr = r.start(rev)
3341 revaddr = r.start(rev)
3340 chainbases.append(baseaddr)
3342 chainbases.append(baseaddr)
3341 chainspans.append((revaddr - baseaddr) + size)
3343 chainspans.append((revaddr - baseaddr) + size)
3342 if size == 0:
3344 if size == 0:
3343 numempty += 1
3345 numempty += 1
3344 numemptydelta += 1
3346 numemptydelta += 1
3345 elif r.issnapshot(rev):
3347 elif r.issnapshot(rev):
3346 addsize(size, semisize)
3348 addsize(size, semisize)
3347 numsemi += 1
3349 numsemi += 1
3348 depth = r.snapshotdepth(rev)
3350 depth = r.snapshotdepth(rev)
3349 numsnapdepth[depth] += 1
3351 numsnapdepth[depth] += 1
3350 addsize(size, snapsizedepth[depth])
3352 addsize(size, snapsizedepth[depth])
3351 else:
3353 else:
3352 addsize(size, deltasize)
3354 addsize(size, deltasize)
3353 if delta == rev - 1:
3355 if delta == rev - 1:
3354 numprev += 1
3356 numprev += 1
3355 if delta == p1:
3357 if delta == p1:
3356 nump1prev += 1
3358 nump1prev += 1
3357 elif delta == p2:
3359 elif delta == p2:
3358 nump2prev += 1
3360 nump2prev += 1
3359 elif delta == p1:
3361 elif delta == p1:
3360 nump1 += 1
3362 nump1 += 1
3361 elif delta == p2:
3363 elif delta == p2:
3362 nump2 += 1
3364 nump2 += 1
3363 elif delta != nullrev:
3365 elif delta != nullrev:
3364 numother += 1
3366 numother += 1
3365
3367
3366 # Obtain data on the raw chunks in the revlog.
3368 # Obtain data on the raw chunks in the revlog.
3367 if util.safehasattr(r, b'_getsegmentforrevs'):
3369 if util.safehasattr(r, b'_getsegmentforrevs'):
3368 segment = r._getsegmentforrevs(rev, rev)[1]
3370 segment = r._getsegmentforrevs(rev, rev)[1]
3369 else:
3371 else:
3370 segment = r._revlog._getsegmentforrevs(rev, rev)[1]
3372 segment = r._revlog._getsegmentforrevs(rev, rev)[1]
3371 if segment:
3373 if segment:
3372 chunktype = bytes(segment[0:1])
3374 chunktype = bytes(segment[0:1])
3373 else:
3375 else:
3374 chunktype = b'empty'
3376 chunktype = b'empty'
3375
3377
3376 if chunktype not in chunktypecounts:
3378 if chunktype not in chunktypecounts:
3377 chunktypecounts[chunktype] = 0
3379 chunktypecounts[chunktype] = 0
3378 chunktypesizes[chunktype] = 0
3380 chunktypesizes[chunktype] = 0
3379
3381
3380 chunktypecounts[chunktype] += 1
3382 chunktypecounts[chunktype] += 1
3381 chunktypesizes[chunktype] += size
3383 chunktypesizes[chunktype] += size
3382
3384
3383 # Adjust size min value for empty cases
3385 # Adjust size min value for empty cases
3384 for size in (datasize, fullsize, semisize, deltasize):
3386 for size in (datasize, fullsize, semisize, deltasize):
3385 if size[0] is None:
3387 if size[0] is None:
3386 size[0] = 0
3388 size[0] = 0
3387
3389
3388 numdeltas = numrevs - numfull - numempty - numsemi
3390 numdeltas = numrevs - numfull - numempty - numsemi
3389 numoprev = numprev - nump1prev - nump2prev
3391 numoprev = numprev - nump1prev - nump2prev
3390 totalrawsize = datasize[2]
3392 totalrawsize = datasize[2]
3391 datasize[2] /= numrevs
3393 datasize[2] /= numrevs
3392 fulltotal = fullsize[2]
3394 fulltotal = fullsize[2]
3393 if numfull == 0:
3395 if numfull == 0:
3394 fullsize[2] = 0
3396 fullsize[2] = 0
3395 else:
3397 else:
3396 fullsize[2] /= numfull
3398 fullsize[2] /= numfull
3397 semitotal = semisize[2]
3399 semitotal = semisize[2]
3398 snaptotal = {}
3400 snaptotal = {}
3399 if numsemi > 0:
3401 if numsemi > 0:
3400 semisize[2] /= numsemi
3402 semisize[2] /= numsemi
3401 for depth in snapsizedepth:
3403 for depth in snapsizedepth:
3402 snaptotal[depth] = snapsizedepth[depth][2]
3404 snaptotal[depth] = snapsizedepth[depth][2]
3403 snapsizedepth[depth][2] /= numsnapdepth[depth]
3405 snapsizedepth[depth][2] /= numsnapdepth[depth]
3404
3406
3405 deltatotal = deltasize[2]
3407 deltatotal = deltasize[2]
3406 if numdeltas > 0:
3408 if numdeltas > 0:
3407 deltasize[2] /= numdeltas
3409 deltasize[2] /= numdeltas
3408 totalsize = fulltotal + semitotal + deltatotal
3410 totalsize = fulltotal + semitotal + deltatotal
3409 avgchainlen = sum(chainlengths) / numrevs
3411 avgchainlen = sum(chainlengths) / numrevs
3410 maxchainlen = max(chainlengths)
3412 maxchainlen = max(chainlengths)
3411 maxchainspan = max(chainspans)
3413 maxchainspan = max(chainspans)
3412 compratio = 1
3414 compratio = 1
3413 if totalsize:
3415 if totalsize:
3414 compratio = totalrawsize / totalsize
3416 compratio = totalrawsize / totalsize
3415
3417
3416 basedfmtstr = b'%%%dd\n'
3418 basedfmtstr = b'%%%dd\n'
3417 basepcfmtstr = b'%%%dd %s(%%5.2f%%%%)\n'
3419 basepcfmtstr = b'%%%dd %s(%%5.2f%%%%)\n'
3418
3420
3419 def dfmtstr(max):
3421 def dfmtstr(max):
3420 return basedfmtstr % len(str(max))
3422 return basedfmtstr % len(str(max))
3421
3423
3422 def pcfmtstr(max, padding=0):
3424 def pcfmtstr(max, padding=0):
3423 return basepcfmtstr % (len(str(max)), b' ' * padding)
3425 return basepcfmtstr % (len(str(max)), b' ' * padding)
3424
3426
3425 def pcfmt(value, total):
3427 def pcfmt(value, total):
3426 if total:
3428 if total:
3427 return (value, 100 * float(value) / total)
3429 return (value, 100 * float(value) / total)
3428 else:
3430 else:
3429 return value, 100.0
3431 return value, 100.0
3430
3432
3431 ui.writenoi18n(b'format : %d\n' % format)
3433 ui.writenoi18n(b'format : %d\n' % format)
3432 ui.writenoi18n(b'flags : %s\n' % b', '.join(flags))
3434 ui.writenoi18n(b'flags : %s\n' % b', '.join(flags))
3433
3435
3434 ui.write(b'\n')
3436 ui.write(b'\n')
3435 fmt = pcfmtstr(totalsize)
3437 fmt = pcfmtstr(totalsize)
3436 fmt2 = dfmtstr(totalsize)
3438 fmt2 = dfmtstr(totalsize)
3437 ui.writenoi18n(b'revisions : ' + fmt2 % numrevs)
3439 ui.writenoi18n(b'revisions : ' + fmt2 % numrevs)
3438 ui.writenoi18n(b' merges : ' + fmt % pcfmt(nummerges, numrevs))
3440 ui.writenoi18n(b' merges : ' + fmt % pcfmt(nummerges, numrevs))
3439 ui.writenoi18n(
3441 ui.writenoi18n(
3440 b' normal : ' + fmt % pcfmt(numrevs - nummerges, numrevs)
3442 b' normal : ' + fmt % pcfmt(numrevs - nummerges, numrevs)
3441 )
3443 )
3442 ui.writenoi18n(b'revisions : ' + fmt2 % numrevs)
3444 ui.writenoi18n(b'revisions : ' + fmt2 % numrevs)
3443 ui.writenoi18n(b' empty : ' + fmt % pcfmt(numempty, numrevs))
3445 ui.writenoi18n(b' empty : ' + fmt % pcfmt(numempty, numrevs))
3444 ui.writenoi18n(
3446 ui.writenoi18n(
3445 b' text : '
3447 b' text : '
3446 + fmt % pcfmt(numemptytext, numemptytext + numemptydelta)
3448 + fmt % pcfmt(numemptytext, numemptytext + numemptydelta)
3447 )
3449 )
3448 ui.writenoi18n(
3450 ui.writenoi18n(
3449 b' delta : '
3451 b' delta : '
3450 + fmt % pcfmt(numemptydelta, numemptytext + numemptydelta)
3452 + fmt % pcfmt(numemptydelta, numemptytext + numemptydelta)
3451 )
3453 )
3452 ui.writenoi18n(
3454 ui.writenoi18n(
3453 b' snapshot : ' + fmt % pcfmt(numfull + numsemi, numrevs)
3455 b' snapshot : ' + fmt % pcfmt(numfull + numsemi, numrevs)
3454 )
3456 )
3455 for depth in sorted(numsnapdepth):
3457 for depth in sorted(numsnapdepth):
3456 ui.write(
3458 ui.write(
3457 (b' lvl-%-3d : ' % depth)
3459 (b' lvl-%-3d : ' % depth)
3458 + fmt % pcfmt(numsnapdepth[depth], numrevs)
3460 + fmt % pcfmt(numsnapdepth[depth], numrevs)
3459 )
3461 )
3460 ui.writenoi18n(b' deltas : ' + fmt % pcfmt(numdeltas, numrevs))
3462 ui.writenoi18n(b' deltas : ' + fmt % pcfmt(numdeltas, numrevs))
3461 ui.writenoi18n(b'revision size : ' + fmt2 % totalsize)
3463 ui.writenoi18n(b'revision size : ' + fmt2 % totalsize)
3462 ui.writenoi18n(
3464 ui.writenoi18n(
3463 b' snapshot : ' + fmt % pcfmt(fulltotal + semitotal, totalsize)
3465 b' snapshot : ' + fmt % pcfmt(fulltotal + semitotal, totalsize)
3464 )
3466 )
3465 for depth in sorted(numsnapdepth):
3467 for depth in sorted(numsnapdepth):
3466 ui.write(
3468 ui.write(
3467 (b' lvl-%-3d : ' % depth)
3469 (b' lvl-%-3d : ' % depth)
3468 + fmt % pcfmt(snaptotal[depth], totalsize)
3470 + fmt % pcfmt(snaptotal[depth], totalsize)
3469 )
3471 )
3470 ui.writenoi18n(b' deltas : ' + fmt % pcfmt(deltatotal, totalsize))
3472 ui.writenoi18n(b' deltas : ' + fmt % pcfmt(deltatotal, totalsize))
3471
3473
3472 def fmtchunktype(chunktype):
3474 def fmtchunktype(chunktype):
3473 if chunktype == b'empty':
3475 if chunktype == b'empty':
3474 return b' %s : ' % chunktype
3476 return b' %s : ' % chunktype
3475 elif chunktype in pycompat.bytestr(string.ascii_letters):
3477 elif chunktype in pycompat.bytestr(string.ascii_letters):
3476 return b' 0x%s (%s) : ' % (hex(chunktype), chunktype)
3478 return b' 0x%s (%s) : ' % (hex(chunktype), chunktype)
3477 else:
3479 else:
3478 return b' 0x%s : ' % hex(chunktype)
3480 return b' 0x%s : ' % hex(chunktype)
3479
3481
3480 ui.write(b'\n')
3482 ui.write(b'\n')
3481 ui.writenoi18n(b'chunks : ' + fmt2 % numrevs)
3483 ui.writenoi18n(b'chunks : ' + fmt2 % numrevs)
3482 for chunktype in sorted(chunktypecounts):
3484 for chunktype in sorted(chunktypecounts):
3483 ui.write(fmtchunktype(chunktype))
3485 ui.write(fmtchunktype(chunktype))
3484 ui.write(fmt % pcfmt(chunktypecounts[chunktype], numrevs))
3486 ui.write(fmt % pcfmt(chunktypecounts[chunktype], numrevs))
3485 ui.writenoi18n(b'chunks size : ' + fmt2 % totalsize)
3487 ui.writenoi18n(b'chunks size : ' + fmt2 % totalsize)
3486 for chunktype in sorted(chunktypecounts):
3488 for chunktype in sorted(chunktypecounts):
3487 ui.write(fmtchunktype(chunktype))
3489 ui.write(fmtchunktype(chunktype))
3488 ui.write(fmt % pcfmt(chunktypesizes[chunktype], totalsize))
3490 ui.write(fmt % pcfmt(chunktypesizes[chunktype], totalsize))
3489
3491
3490 ui.write(b'\n')
3492 ui.write(b'\n')
3491 fmt = dfmtstr(max(avgchainlen, maxchainlen, maxchainspan, compratio))
3493 fmt = dfmtstr(max(avgchainlen, maxchainlen, maxchainspan, compratio))
3492 ui.writenoi18n(b'avg chain length : ' + fmt % avgchainlen)
3494 ui.writenoi18n(b'avg chain length : ' + fmt % avgchainlen)
3493 ui.writenoi18n(b'max chain length : ' + fmt % maxchainlen)
3495 ui.writenoi18n(b'max chain length : ' + fmt % maxchainlen)
3494 ui.writenoi18n(b'max chain reach : ' + fmt % maxchainspan)
3496 ui.writenoi18n(b'max chain reach : ' + fmt % maxchainspan)
3495 ui.writenoi18n(b'compression ratio : ' + fmt % compratio)
3497 ui.writenoi18n(b'compression ratio : ' + fmt % compratio)
3496
3498
3497 if format > 0:
3499 if format > 0:
3498 ui.write(b'\n')
3500 ui.write(b'\n')
3499 ui.writenoi18n(
3501 ui.writenoi18n(
3500 b'uncompressed data size (min/max/avg) : %d / %d / %d\n'
3502 b'uncompressed data size (min/max/avg) : %d / %d / %d\n'
3501 % tuple(datasize)
3503 % tuple(datasize)
3502 )
3504 )
3503 ui.writenoi18n(
3505 ui.writenoi18n(
3504 b'full revision size (min/max/avg) : %d / %d / %d\n'
3506 b'full revision size (min/max/avg) : %d / %d / %d\n'
3505 % tuple(fullsize)
3507 % tuple(fullsize)
3506 )
3508 )
3507 ui.writenoi18n(
3509 ui.writenoi18n(
3508 b'inter-snapshot size (min/max/avg) : %d / %d / %d\n'
3510 b'inter-snapshot size (min/max/avg) : %d / %d / %d\n'
3509 % tuple(semisize)
3511 % tuple(semisize)
3510 )
3512 )
3511 for depth in sorted(snapsizedepth):
3513 for depth in sorted(snapsizedepth):
3512 if depth == 0:
3514 if depth == 0:
3513 continue
3515 continue
3514 ui.writenoi18n(
3516 ui.writenoi18n(
3515 b' level-%-3d (min/max/avg) : %d / %d / %d\n'
3517 b' level-%-3d (min/max/avg) : %d / %d / %d\n'
3516 % ((depth,) + tuple(snapsizedepth[depth]))
3518 % ((depth,) + tuple(snapsizedepth[depth]))
3517 )
3519 )
3518 ui.writenoi18n(
3520 ui.writenoi18n(
3519 b'delta size (min/max/avg) : %d / %d / %d\n'
3521 b'delta size (min/max/avg) : %d / %d / %d\n'
3520 % tuple(deltasize)
3522 % tuple(deltasize)
3521 )
3523 )
3522
3524
3523 if numdeltas > 0:
3525 if numdeltas > 0:
3524 ui.write(b'\n')
3526 ui.write(b'\n')
3525 fmt = pcfmtstr(numdeltas)
3527 fmt = pcfmtstr(numdeltas)
3526 fmt2 = pcfmtstr(numdeltas, 4)
3528 fmt2 = pcfmtstr(numdeltas, 4)
3527 ui.writenoi18n(
3529 ui.writenoi18n(
3528 b'deltas against prev : ' + fmt % pcfmt(numprev, numdeltas)
3530 b'deltas against prev : ' + fmt % pcfmt(numprev, numdeltas)
3529 )
3531 )
3530 if numprev > 0:
3532 if numprev > 0:
3531 ui.writenoi18n(
3533 ui.writenoi18n(
3532 b' where prev = p1 : ' + fmt2 % pcfmt(nump1prev, numprev)
3534 b' where prev = p1 : ' + fmt2 % pcfmt(nump1prev, numprev)
3533 )
3535 )
3534 ui.writenoi18n(
3536 ui.writenoi18n(
3535 b' where prev = p2 : ' + fmt2 % pcfmt(nump2prev, numprev)
3537 b' where prev = p2 : ' + fmt2 % pcfmt(nump2prev, numprev)
3536 )
3538 )
3537 ui.writenoi18n(
3539 ui.writenoi18n(
3538 b' other : ' + fmt2 % pcfmt(numoprev, numprev)
3540 b' other : ' + fmt2 % pcfmt(numoprev, numprev)
3539 )
3541 )
3540 if gdelta:
3542 if gdelta:
3541 ui.writenoi18n(
3543 ui.writenoi18n(
3542 b'deltas against p1 : ' + fmt % pcfmt(nump1, numdeltas)
3544 b'deltas against p1 : ' + fmt % pcfmt(nump1, numdeltas)
3543 )
3545 )
3544 ui.writenoi18n(
3546 ui.writenoi18n(
3545 b'deltas against p2 : ' + fmt % pcfmt(nump2, numdeltas)
3547 b'deltas against p2 : ' + fmt % pcfmt(nump2, numdeltas)
3546 )
3548 )
3547 ui.writenoi18n(
3549 ui.writenoi18n(
3548 b'deltas against other : ' + fmt % pcfmt(numother, numdeltas)
3550 b'deltas against other : ' + fmt % pcfmt(numother, numdeltas)
3549 )
3551 )
3550
3552
3551
3553
3552 @command(
3554 @command(
3553 b'debugrevlogindex',
3555 b'debugrevlogindex',
3554 cmdutil.debugrevlogopts
3556 cmdutil.debugrevlogopts
3555 + [(b'f', b'format', 0, _(b'revlog format'), _(b'FORMAT'))],
3557 + [(b'f', b'format', 0, _(b'revlog format'), _(b'FORMAT'))],
3556 _(b'[-f FORMAT] -c|-m|FILE'),
3558 _(b'[-f FORMAT] -c|-m|FILE'),
3557 optionalrepo=True,
3559 optionalrepo=True,
3558 )
3560 )
3559 def debugrevlogindex(ui, repo, file_=None, **opts):
3561 def debugrevlogindex(ui, repo, file_=None, **opts):
3560 """dump the contents of a revlog index"""
3562 """dump the contents of a revlog index"""
3561 opts = pycompat.byteskwargs(opts)
3563 opts = pycompat.byteskwargs(opts)
3562 r = cmdutil.openrevlog(repo, b'debugrevlogindex', file_, opts)
3564 r = cmdutil.openrevlog(repo, b'debugrevlogindex', file_, opts)
3563 format = opts.get(b'format', 0)
3565 format = opts.get(b'format', 0)
3564 if format not in (0, 1):
3566 if format not in (0, 1):
3565 raise error.Abort(_(b"unknown format %d") % format)
3567 raise error.Abort(_(b"unknown format %d") % format)
3566
3568
3567 if ui.debugflag:
3569 if ui.debugflag:
3568 shortfn = hex
3570 shortfn = hex
3569 else:
3571 else:
3570 shortfn = short
3572 shortfn = short
3571
3573
3572 # There might not be anything in r, so have a sane default
3574 # There might not be anything in r, so have a sane default
3573 idlen = 12
3575 idlen = 12
3574 for i in r:
3576 for i in r:
3575 idlen = len(shortfn(r.node(i)))
3577 idlen = len(shortfn(r.node(i)))
3576 break
3578 break
3577
3579
3578 if format == 0:
3580 if format == 0:
3579 if ui.verbose:
3581 if ui.verbose:
3580 ui.writenoi18n(
3582 ui.writenoi18n(
3581 b" rev offset length linkrev %s %s p2\n"
3583 b" rev offset length linkrev %s %s p2\n"
3582 % (b"nodeid".ljust(idlen), b"p1".ljust(idlen))
3584 % (b"nodeid".ljust(idlen), b"p1".ljust(idlen))
3583 )
3585 )
3584 else:
3586 else:
3585 ui.writenoi18n(
3587 ui.writenoi18n(
3586 b" rev linkrev %s %s p2\n"
3588 b" rev linkrev %s %s p2\n"
3587 % (b"nodeid".ljust(idlen), b"p1".ljust(idlen))
3589 % (b"nodeid".ljust(idlen), b"p1".ljust(idlen))
3588 )
3590 )
3589 elif format == 1:
3591 elif format == 1:
3590 if ui.verbose:
3592 if ui.verbose:
3591 ui.writenoi18n(
3593 ui.writenoi18n(
3592 (
3594 (
3593 b" rev flag offset length size link p1"
3595 b" rev flag offset length size link p1"
3594 b" p2 %s\n"
3596 b" p2 %s\n"
3595 )
3597 )
3596 % b"nodeid".rjust(idlen)
3598 % b"nodeid".rjust(idlen)
3597 )
3599 )
3598 else:
3600 else:
3599 ui.writenoi18n(
3601 ui.writenoi18n(
3600 b" rev flag size link p1 p2 %s\n"
3602 b" rev flag size link p1 p2 %s\n"
3601 % b"nodeid".rjust(idlen)
3603 % b"nodeid".rjust(idlen)
3602 )
3604 )
3603
3605
3604 for i in r:
3606 for i in r:
3605 node = r.node(i)
3607 node = r.node(i)
3606 if format == 0:
3608 if format == 0:
3607 try:
3609 try:
3608 pp = r.parents(node)
3610 pp = r.parents(node)
3609 except Exception:
3611 except Exception:
3610 pp = [repo.nullid, repo.nullid]
3612 pp = [repo.nullid, repo.nullid]
3611 if ui.verbose:
3613 if ui.verbose:
3612 ui.write(
3614 ui.write(
3613 b"% 6d % 9d % 7d % 7d %s %s %s\n"
3615 b"% 6d % 9d % 7d % 7d %s %s %s\n"
3614 % (
3616 % (
3615 i,
3617 i,
3616 r.start(i),
3618 r.start(i),
3617 r.length(i),
3619 r.length(i),
3618 r.linkrev(i),
3620 r.linkrev(i),
3619 shortfn(node),
3621 shortfn(node),
3620 shortfn(pp[0]),
3622 shortfn(pp[0]),
3621 shortfn(pp[1]),
3623 shortfn(pp[1]),
3622 )
3624 )
3623 )
3625 )
3624 else:
3626 else:
3625 ui.write(
3627 ui.write(
3626 b"% 6d % 7d %s %s %s\n"
3628 b"% 6d % 7d %s %s %s\n"
3627 % (
3629 % (
3628 i,
3630 i,
3629 r.linkrev(i),
3631 r.linkrev(i),
3630 shortfn(node),
3632 shortfn(node),
3631 shortfn(pp[0]),
3633 shortfn(pp[0]),
3632 shortfn(pp[1]),
3634 shortfn(pp[1]),
3633 )
3635 )
3634 )
3636 )
3635 elif format == 1:
3637 elif format == 1:
3636 pr = r.parentrevs(i)
3638 pr = r.parentrevs(i)
3637 if ui.verbose:
3639 if ui.verbose:
3638 ui.write(
3640 ui.write(
3639 b"% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d %s\n"
3641 b"% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d %s\n"
3640 % (
3642 % (
3641 i,
3643 i,
3642 r.flags(i),
3644 r.flags(i),
3643 r.start(i),
3645 r.start(i),
3644 r.length(i),
3646 r.length(i),
3645 r.rawsize(i),
3647 r.rawsize(i),
3646 r.linkrev(i),
3648 r.linkrev(i),
3647 pr[0],
3649 pr[0],
3648 pr[1],
3650 pr[1],
3649 shortfn(node),
3651 shortfn(node),
3650 )
3652 )
3651 )
3653 )
3652 else:
3654 else:
3653 ui.write(
3655 ui.write(
3654 b"% 6d %04x % 8d % 6d % 6d % 6d %s\n"
3656 b"% 6d %04x % 8d % 6d % 6d % 6d %s\n"
3655 % (
3657 % (
3656 i,
3658 i,
3657 r.flags(i),
3659 r.flags(i),
3658 r.rawsize(i),
3660 r.rawsize(i),
3659 r.linkrev(i),
3661 r.linkrev(i),
3660 pr[0],
3662 pr[0],
3661 pr[1],
3663 pr[1],
3662 shortfn(node),
3664 shortfn(node),
3663 )
3665 )
3664 )
3666 )
3665
3667
3666
3668
3667 @command(
3669 @command(
3668 b'debugrevspec',
3670 b'debugrevspec',
3669 [
3671 [
3670 (
3672 (
3671 b'',
3673 b'',
3672 b'optimize',
3674 b'optimize',
3673 None,
3675 None,
3674 _(b'print parsed tree after optimizing (DEPRECATED)'),
3676 _(b'print parsed tree after optimizing (DEPRECATED)'),
3675 ),
3677 ),
3676 (
3678 (
3677 b'',
3679 b'',
3678 b'show-revs',
3680 b'show-revs',
3679 True,
3681 True,
3680 _(b'print list of result revisions (default)'),
3682 _(b'print list of result revisions (default)'),
3681 ),
3683 ),
3682 (
3684 (
3683 b's',
3685 b's',
3684 b'show-set',
3686 b'show-set',
3685 None,
3687 None,
3686 _(b'print internal representation of result set'),
3688 _(b'print internal representation of result set'),
3687 ),
3689 ),
3688 (
3690 (
3689 b'p',
3691 b'p',
3690 b'show-stage',
3692 b'show-stage',
3691 [],
3693 [],
3692 _(b'print parsed tree at the given stage'),
3694 _(b'print parsed tree at the given stage'),
3693 _(b'NAME'),
3695 _(b'NAME'),
3694 ),
3696 ),
3695 (b'', b'no-optimized', False, _(b'evaluate tree without optimization')),
3697 (b'', b'no-optimized', False, _(b'evaluate tree without optimization')),
3696 (b'', b'verify-optimized', False, _(b'verify optimized result')),
3698 (b'', b'verify-optimized', False, _(b'verify optimized result')),
3697 ],
3699 ],
3698 b'REVSPEC',
3700 b'REVSPEC',
3699 )
3701 )
3700 def debugrevspec(ui, repo, expr, **opts):
3702 def debugrevspec(ui, repo, expr, **opts):
3701 """parse and apply a revision specification
3703 """parse and apply a revision specification
3702
3704
3703 Use -p/--show-stage option to print the parsed tree at the given stages.
3705 Use -p/--show-stage option to print the parsed tree at the given stages.
3704 Use -p all to print tree at every stage.
3706 Use -p all to print tree at every stage.
3705
3707
3706 Use --no-show-revs option with -s or -p to print only the set
3708 Use --no-show-revs option with -s or -p to print only the set
3707 representation or the parsed tree respectively.
3709 representation or the parsed tree respectively.
3708
3710
3709 Use --verify-optimized to compare the optimized result with the unoptimized
3711 Use --verify-optimized to compare the optimized result with the unoptimized
3710 one. Returns 1 if the optimized result differs.
3712 one. Returns 1 if the optimized result differs.
3711 """
3713 """
3712 opts = pycompat.byteskwargs(opts)
3714 opts = pycompat.byteskwargs(opts)
3713 aliases = ui.configitems(b'revsetalias')
3715 aliases = ui.configitems(b'revsetalias')
3714 stages = [
3716 stages = [
3715 (b'parsed', lambda tree: tree),
3717 (b'parsed', lambda tree: tree),
3716 (
3718 (
3717 b'expanded',
3719 b'expanded',
3718 lambda tree: revsetlang.expandaliases(tree, aliases, ui.warn),
3720 lambda tree: revsetlang.expandaliases(tree, aliases, ui.warn),
3719 ),
3721 ),
3720 (b'concatenated', revsetlang.foldconcat),
3722 (b'concatenated', revsetlang.foldconcat),
3721 (b'analyzed', revsetlang.analyze),
3723 (b'analyzed', revsetlang.analyze),
3722 (b'optimized', revsetlang.optimize),
3724 (b'optimized', revsetlang.optimize),
3723 ]
3725 ]
3724 if opts[b'no_optimized']:
3726 if opts[b'no_optimized']:
3725 stages = stages[:-1]
3727 stages = stages[:-1]
3726 if opts[b'verify_optimized'] and opts[b'no_optimized']:
3728 if opts[b'verify_optimized'] and opts[b'no_optimized']:
3727 raise error.Abort(
3729 raise error.Abort(
3728 _(b'cannot use --verify-optimized with --no-optimized')
3730 _(b'cannot use --verify-optimized with --no-optimized')
3729 )
3731 )
3730 stagenames = {n for n, f in stages}
3732 stagenames = {n for n, f in stages}
3731
3733
3732 showalways = set()
3734 showalways = set()
3733 showchanged = set()
3735 showchanged = set()
3734 if ui.verbose and not opts[b'show_stage']:
3736 if ui.verbose and not opts[b'show_stage']:
3735 # show parsed tree by --verbose (deprecated)
3737 # show parsed tree by --verbose (deprecated)
3736 showalways.add(b'parsed')
3738 showalways.add(b'parsed')
3737 showchanged.update([b'expanded', b'concatenated'])
3739 showchanged.update([b'expanded', b'concatenated'])
3738 if opts[b'optimize']:
3740 if opts[b'optimize']:
3739 showalways.add(b'optimized')
3741 showalways.add(b'optimized')
3740 if opts[b'show_stage'] and opts[b'optimize']:
3742 if opts[b'show_stage'] and opts[b'optimize']:
3741 raise error.Abort(_(b'cannot use --optimize with --show-stage'))
3743 raise error.Abort(_(b'cannot use --optimize with --show-stage'))
3742 if opts[b'show_stage'] == [b'all']:
3744 if opts[b'show_stage'] == [b'all']:
3743 showalways.update(stagenames)
3745 showalways.update(stagenames)
3744 else:
3746 else:
3745 for n in opts[b'show_stage']:
3747 for n in opts[b'show_stage']:
3746 if n not in stagenames:
3748 if n not in stagenames:
3747 raise error.Abort(_(b'invalid stage name: %s') % n)
3749 raise error.Abort(_(b'invalid stage name: %s') % n)
3748 showalways.update(opts[b'show_stage'])
3750 showalways.update(opts[b'show_stage'])
3749
3751
3750 treebystage = {}
3752 treebystage = {}
3751 printedtree = None
3753 printedtree = None
3752 tree = revsetlang.parse(expr, lookup=revset.lookupfn(repo))
3754 tree = revsetlang.parse(expr, lookup=revset.lookupfn(repo))
3753 for n, f in stages:
3755 for n, f in stages:
3754 treebystage[n] = tree = f(tree)
3756 treebystage[n] = tree = f(tree)
3755 if n in showalways or (n in showchanged and tree != printedtree):
3757 if n in showalways or (n in showchanged and tree != printedtree):
3756 if opts[b'show_stage'] or n != b'parsed':
3758 if opts[b'show_stage'] or n != b'parsed':
3757 ui.write(b"* %s:\n" % n)
3759 ui.write(b"* %s:\n" % n)
3758 ui.write(revsetlang.prettyformat(tree), b"\n")
3760 ui.write(revsetlang.prettyformat(tree), b"\n")
3759 printedtree = tree
3761 printedtree = tree
3760
3762
3761 if opts[b'verify_optimized']:
3763 if opts[b'verify_optimized']:
3762 arevs = revset.makematcher(treebystage[b'analyzed'])(repo)
3764 arevs = revset.makematcher(treebystage[b'analyzed'])(repo)
3763 brevs = revset.makematcher(treebystage[b'optimized'])(repo)
3765 brevs = revset.makematcher(treebystage[b'optimized'])(repo)
3764 if opts[b'show_set'] or (opts[b'show_set'] is None and ui.verbose):
3766 if opts[b'show_set'] or (opts[b'show_set'] is None and ui.verbose):
3765 ui.writenoi18n(
3767 ui.writenoi18n(
3766 b"* analyzed set:\n", stringutil.prettyrepr(arevs), b"\n"
3768 b"* analyzed set:\n", stringutil.prettyrepr(arevs), b"\n"
3767 )
3769 )
3768 ui.writenoi18n(
3770 ui.writenoi18n(
3769 b"* optimized set:\n", stringutil.prettyrepr(brevs), b"\n"
3771 b"* optimized set:\n", stringutil.prettyrepr(brevs), b"\n"
3770 )
3772 )
3771 arevs = list(arevs)
3773 arevs = list(arevs)
3772 brevs = list(brevs)
3774 brevs = list(brevs)
3773 if arevs == brevs:
3775 if arevs == brevs:
3774 return 0
3776 return 0
3775 ui.writenoi18n(b'--- analyzed\n', label=b'diff.file_a')
3777 ui.writenoi18n(b'--- analyzed\n', label=b'diff.file_a')
3776 ui.writenoi18n(b'+++ optimized\n', label=b'diff.file_b')
3778 ui.writenoi18n(b'+++ optimized\n', label=b'diff.file_b')
3777 sm = difflib.SequenceMatcher(None, arevs, brevs)
3779 sm = difflib.SequenceMatcher(None, arevs, brevs)
3778 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
3780 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
3779 if tag in ('delete', 'replace'):
3781 if tag in ('delete', 'replace'):
3780 for c in arevs[alo:ahi]:
3782 for c in arevs[alo:ahi]:
3781 ui.write(b'-%d\n' % c, label=b'diff.deleted')
3783 ui.write(b'-%d\n' % c, label=b'diff.deleted')
3782 if tag in ('insert', 'replace'):
3784 if tag in ('insert', 'replace'):
3783 for c in brevs[blo:bhi]:
3785 for c in brevs[blo:bhi]:
3784 ui.write(b'+%d\n' % c, label=b'diff.inserted')
3786 ui.write(b'+%d\n' % c, label=b'diff.inserted')
3785 if tag == 'equal':
3787 if tag == 'equal':
3786 for c in arevs[alo:ahi]:
3788 for c in arevs[alo:ahi]:
3787 ui.write(b' %d\n' % c)
3789 ui.write(b' %d\n' % c)
3788 return 1
3790 return 1
3789
3791
3790 func = revset.makematcher(tree)
3792 func = revset.makematcher(tree)
3791 revs = func(repo)
3793 revs = func(repo)
3792 if opts[b'show_set'] or (opts[b'show_set'] is None and ui.verbose):
3794 if opts[b'show_set'] or (opts[b'show_set'] is None and ui.verbose):
3793 ui.writenoi18n(b"* set:\n", stringutil.prettyrepr(revs), b"\n")
3795 ui.writenoi18n(b"* set:\n", stringutil.prettyrepr(revs), b"\n")
3794 if not opts[b'show_revs']:
3796 if not opts[b'show_revs']:
3795 return
3797 return
3796 for c in revs:
3798 for c in revs:
3797 ui.write(b"%d\n" % c)
3799 ui.write(b"%d\n" % c)
3798
3800
3799
3801
3800 @command(
3802 @command(
3801 b'debugserve',
3803 b'debugserve',
3802 [
3804 [
3803 (
3805 (
3804 b'',
3806 b'',
3805 b'sshstdio',
3807 b'sshstdio',
3806 False,
3808 False,
3807 _(b'run an SSH server bound to process handles'),
3809 _(b'run an SSH server bound to process handles'),
3808 ),
3810 ),
3809 (b'', b'logiofd', b'', _(b'file descriptor to log server I/O to')),
3811 (b'', b'logiofd', b'', _(b'file descriptor to log server I/O to')),
3810 (b'', b'logiofile', b'', _(b'file to log server I/O to')),
3812 (b'', b'logiofile', b'', _(b'file to log server I/O to')),
3811 ],
3813 ],
3812 b'',
3814 b'',
3813 )
3815 )
3814 def debugserve(ui, repo, **opts):
3816 def debugserve(ui, repo, **opts):
3815 """run a server with advanced settings
3817 """run a server with advanced settings
3816
3818
3817 This command is similar to :hg:`serve`. It exists partially as a
3819 This command is similar to :hg:`serve`. It exists partially as a
3818 workaround to the fact that ``hg serve --stdio`` must have specific
3820 workaround to the fact that ``hg serve --stdio`` must have specific
3819 arguments for security reasons.
3821 arguments for security reasons.
3820 """
3822 """
3821 opts = pycompat.byteskwargs(opts)
3823 opts = pycompat.byteskwargs(opts)
3822
3824
3823 if not opts[b'sshstdio']:
3825 if not opts[b'sshstdio']:
3824 raise error.Abort(_(b'only --sshstdio is currently supported'))
3826 raise error.Abort(_(b'only --sshstdio is currently supported'))
3825
3827
3826 logfh = None
3828 logfh = None
3827
3829
3828 if opts[b'logiofd'] and opts[b'logiofile']:
3830 if opts[b'logiofd'] and opts[b'logiofile']:
3829 raise error.Abort(_(b'cannot use both --logiofd and --logiofile'))
3831 raise error.Abort(_(b'cannot use both --logiofd and --logiofile'))
3830
3832
3831 if opts[b'logiofd']:
3833 if opts[b'logiofd']:
3832 # Ideally we would be line buffered. But line buffering in binary
3834 # Ideally we would be line buffered. But line buffering in binary
3833 # mode isn't supported and emits a warning in Python 3.8+. Disabling
3835 # mode isn't supported and emits a warning in Python 3.8+. Disabling
3834 # buffering could have performance impacts. But since this isn't
3836 # buffering could have performance impacts. But since this isn't
3835 # performance critical code, it should be fine.
3837 # performance critical code, it should be fine.
3836 try:
3838 try:
3837 logfh = os.fdopen(int(opts[b'logiofd']), 'ab', 0)
3839 logfh = os.fdopen(int(opts[b'logiofd']), 'ab', 0)
3838 except OSError as e:
3840 except OSError as e:
3839 if e.errno != errno.ESPIPE:
3841 if e.errno != errno.ESPIPE:
3840 raise
3842 raise
3841 # can't seek a pipe, so `ab` mode fails on py3
3843 # can't seek a pipe, so `ab` mode fails on py3
3842 logfh = os.fdopen(int(opts[b'logiofd']), 'wb', 0)
3844 logfh = os.fdopen(int(opts[b'logiofd']), 'wb', 0)
3843 elif opts[b'logiofile']:
3845 elif opts[b'logiofile']:
3844 logfh = open(opts[b'logiofile'], b'ab', 0)
3846 logfh = open(opts[b'logiofile'], b'ab', 0)
3845
3847
3846 s = wireprotoserver.sshserver(ui, repo, logfh=logfh)
3848 s = wireprotoserver.sshserver(ui, repo, logfh=logfh)
3847 s.serve_forever()
3849 s.serve_forever()
3848
3850
3849
3851
3850 @command(b'debugsetparents', [], _(b'REV1 [REV2]'))
3852 @command(b'debugsetparents', [], _(b'REV1 [REV2]'))
3851 def debugsetparents(ui, repo, rev1, rev2=None):
3853 def debugsetparents(ui, repo, rev1, rev2=None):
3852 """manually set the parents of the current working directory (DANGEROUS)
3854 """manually set the parents of the current working directory (DANGEROUS)
3853
3855
3854 This command is not what you are looking for and should not be used. Using
3856 This command is not what you are looking for and should not be used. Using
3855 this command will most certainly results in slight corruption of the file
3857 this command will most certainly results in slight corruption of the file
3856 level histories withing your repository. DO NOT USE THIS COMMAND.
3858 level histories withing your repository. DO NOT USE THIS COMMAND.
3857
3859
3858 The command update the p1 and p2 field in the dirstate, and not touching
3860 The command update the p1 and p2 field in the dirstate, and not touching
3859 anything else. This useful for writing repository conversion tools, but
3861 anything else. This useful for writing repository conversion tools, but
3860 should be used with extreme care. For example, neither the working
3862 should be used with extreme care. For example, neither the working
3861 directory nor the dirstate is updated, so file status may be incorrect
3863 directory nor the dirstate is updated, so file status may be incorrect
3862 after running this command. Only used if you are one of the few people that
3864 after running this command. Only used if you are one of the few people that
3863 deeply unstand both conversion tools and file level histories. If you are
3865 deeply unstand both conversion tools and file level histories. If you are
3864 reading this help, you are not one of this people (most of them sailed west
3866 reading this help, you are not one of this people (most of them sailed west
3865 from Mithlond anyway.
3867 from Mithlond anyway.
3866
3868
3867 So one last time DO NOT USE THIS COMMAND.
3869 So one last time DO NOT USE THIS COMMAND.
3868
3870
3869 Returns 0 on success.
3871 Returns 0 on success.
3870 """
3872 """
3871
3873
3872 node1 = scmutil.revsingle(repo, rev1).node()
3874 node1 = scmutil.revsingle(repo, rev1).node()
3873 node2 = scmutil.revsingle(repo, rev2, b'null').node()
3875 node2 = scmutil.revsingle(repo, rev2, b'null').node()
3874
3876
3875 with repo.wlock():
3877 with repo.wlock():
3876 repo.setparents(node1, node2)
3878 repo.setparents(node1, node2)
3877
3879
3878
3880
3879 @command(b'debugsidedata', cmdutil.debugrevlogopts, _(b'-c|-m|FILE REV'))
3881 @command(b'debugsidedata', cmdutil.debugrevlogopts, _(b'-c|-m|FILE REV'))
3880 def debugsidedata(ui, repo, file_, rev=None, **opts):
3882 def debugsidedata(ui, repo, file_, rev=None, **opts):
3881 """dump the side data for a cl/manifest/file revision
3883 """dump the side data for a cl/manifest/file revision
3882
3884
3883 Use --verbose to dump the sidedata content."""
3885 Use --verbose to dump the sidedata content."""
3884 opts = pycompat.byteskwargs(opts)
3886 opts = pycompat.byteskwargs(opts)
3885 if opts.get(b'changelog') or opts.get(b'manifest') or opts.get(b'dir'):
3887 if opts.get(b'changelog') or opts.get(b'manifest') or opts.get(b'dir'):
3886 if rev is not None:
3888 if rev is not None:
3887 raise error.CommandError(b'debugdata', _(b'invalid arguments'))
3889 raise error.CommandError(b'debugdata', _(b'invalid arguments'))
3888 file_, rev = None, file_
3890 file_, rev = None, file_
3889 elif rev is None:
3891 elif rev is None:
3890 raise error.CommandError(b'debugdata', _(b'invalid arguments'))
3892 raise error.CommandError(b'debugdata', _(b'invalid arguments'))
3891 r = cmdutil.openstorage(repo, b'debugdata', file_, opts)
3893 r = cmdutil.openstorage(repo, b'debugdata', file_, opts)
3892 r = getattr(r, '_revlog', r)
3894 r = getattr(r, '_revlog', r)
3893 try:
3895 try:
3894 sidedata = r.sidedata(r.lookup(rev))
3896 sidedata = r.sidedata(r.lookup(rev))
3895 except KeyError:
3897 except KeyError:
3896 raise error.Abort(_(b'invalid revision identifier %s') % rev)
3898 raise error.Abort(_(b'invalid revision identifier %s') % rev)
3897 if sidedata:
3899 if sidedata:
3898 sidedata = list(sidedata.items())
3900 sidedata = list(sidedata.items())
3899 sidedata.sort()
3901 sidedata.sort()
3900 ui.writenoi18n(b'%d sidedata entries\n' % len(sidedata))
3902 ui.writenoi18n(b'%d sidedata entries\n' % len(sidedata))
3901 for key, value in sidedata:
3903 for key, value in sidedata:
3902 ui.writenoi18n(b' entry-%04o size %d\n' % (key, len(value)))
3904 ui.writenoi18n(b' entry-%04o size %d\n' % (key, len(value)))
3903 if ui.verbose:
3905 if ui.verbose:
3904 ui.writenoi18n(b' %s\n' % stringutil.pprint(value))
3906 ui.writenoi18n(b' %s\n' % stringutil.pprint(value))
3905
3907
3906
3908
3907 @command(b'debugssl', [], b'[SOURCE]', optionalrepo=True)
3909 @command(b'debugssl', [], b'[SOURCE]', optionalrepo=True)
3908 def debugssl(ui, repo, source=None, **opts):
3910 def debugssl(ui, repo, source=None, **opts):
3909 """test a secure connection to a server
3911 """test a secure connection to a server
3910
3912
3911 This builds the certificate chain for the server on Windows, installing the
3913 This builds the certificate chain for the server on Windows, installing the
3912 missing intermediates and trusted root via Windows Update if necessary. It
3914 missing intermediates and trusted root via Windows Update if necessary. It
3913 does nothing on other platforms.
3915 does nothing on other platforms.
3914
3916
3915 If SOURCE is omitted, the 'default' path will be used. If a URL is given,
3917 If SOURCE is omitted, the 'default' path will be used. If a URL is given,
3916 that server is used. See :hg:`help urls` for more information.
3918 that server is used. See :hg:`help urls` for more information.
3917
3919
3918 If the update succeeds, retry the original operation. Otherwise, the cause
3920 If the update succeeds, retry the original operation. Otherwise, the cause
3919 of the SSL error is likely another issue.
3921 of the SSL error is likely another issue.
3920 """
3922 """
3921 if not pycompat.iswindows:
3923 if not pycompat.iswindows:
3922 raise error.Abort(
3924 raise error.Abort(
3923 _(b'certificate chain building is only possible on Windows')
3925 _(b'certificate chain building is only possible on Windows')
3924 )
3926 )
3925
3927
3926 if not source:
3928 if not source:
3927 if not repo:
3929 if not repo:
3928 raise error.Abort(
3930 raise error.Abort(
3929 _(
3931 _(
3930 b"there is no Mercurial repository here, and no "
3932 b"there is no Mercurial repository here, and no "
3931 b"server specified"
3933 b"server specified"
3932 )
3934 )
3933 )
3935 )
3934 source = b"default"
3936 source = b"default"
3935
3937
3936 source, branches = urlutil.get_unique_pull_path(
3938 source, branches = urlutil.get_unique_pull_path(
3937 b'debugssl', repo, ui, source
3939 b'debugssl', repo, ui, source
3938 )
3940 )
3939 url = urlutil.url(source)
3941 url = urlutil.url(source)
3940
3942
3941 defaultport = {b'https': 443, b'ssh': 22}
3943 defaultport = {b'https': 443, b'ssh': 22}
3942 if url.scheme in defaultport:
3944 if url.scheme in defaultport:
3943 try:
3945 try:
3944 addr = (url.host, int(url.port or defaultport[url.scheme]))
3946 addr = (url.host, int(url.port or defaultport[url.scheme]))
3945 except ValueError:
3947 except ValueError:
3946 raise error.Abort(_(b"malformed port number in URL"))
3948 raise error.Abort(_(b"malformed port number in URL"))
3947 else:
3949 else:
3948 raise error.Abort(_(b"only https and ssh connections are supported"))
3950 raise error.Abort(_(b"only https and ssh connections are supported"))
3949
3951
3950 from . import win32
3952 from . import win32
3951
3953
3952 s = ssl.wrap_socket(
3954 s = ssl.wrap_socket(
3953 socket.socket(),
3955 socket.socket(),
3954 ssl_version=ssl.PROTOCOL_TLS,
3956 ssl_version=ssl.PROTOCOL_TLS,
3955 cert_reqs=ssl.CERT_NONE,
3957 cert_reqs=ssl.CERT_NONE,
3956 ca_certs=None,
3958 ca_certs=None,
3957 )
3959 )
3958
3960
3959 try:
3961 try:
3960 s.connect(addr)
3962 s.connect(addr)
3961 cert = s.getpeercert(True)
3963 cert = s.getpeercert(True)
3962
3964
3963 ui.status(_(b'checking the certificate chain for %s\n') % url.host)
3965 ui.status(_(b'checking the certificate chain for %s\n') % url.host)
3964
3966
3965 complete = win32.checkcertificatechain(cert, build=False)
3967 complete = win32.checkcertificatechain(cert, build=False)
3966
3968
3967 if not complete:
3969 if not complete:
3968 ui.status(_(b'certificate chain is incomplete, updating... '))
3970 ui.status(_(b'certificate chain is incomplete, updating... '))
3969
3971
3970 if not win32.checkcertificatechain(cert):
3972 if not win32.checkcertificatechain(cert):
3971 ui.status(_(b'failed.\n'))
3973 ui.status(_(b'failed.\n'))
3972 else:
3974 else:
3973 ui.status(_(b'done.\n'))
3975 ui.status(_(b'done.\n'))
3974 else:
3976 else:
3975 ui.status(_(b'full certificate chain is available\n'))
3977 ui.status(_(b'full certificate chain is available\n'))
3976 finally:
3978 finally:
3977 s.close()
3979 s.close()
3978
3980
3979
3981
3980 @command(
3982 @command(
3981 b"debugbackupbundle",
3983 b"debugbackupbundle",
3982 [
3984 [
3983 (
3985 (
3984 b"",
3986 b"",
3985 b"recover",
3987 b"recover",
3986 b"",
3988 b"",
3987 b"brings the specified changeset back into the repository",
3989 b"brings the specified changeset back into the repository",
3988 )
3990 )
3989 ]
3991 ]
3990 + cmdutil.logopts,
3992 + cmdutil.logopts,
3991 _(b"hg debugbackupbundle [--recover HASH]"),
3993 _(b"hg debugbackupbundle [--recover HASH]"),
3992 )
3994 )
3993 def debugbackupbundle(ui, repo, *pats, **opts):
3995 def debugbackupbundle(ui, repo, *pats, **opts):
3994 """lists the changesets available in backup bundles
3996 """lists the changesets available in backup bundles
3995
3997
3996 Without any arguments, this command prints a list of the changesets in each
3998 Without any arguments, this command prints a list of the changesets in each
3997 backup bundle.
3999 backup bundle.
3998
4000
3999 --recover takes a changeset hash and unbundles the first bundle that
4001 --recover takes a changeset hash and unbundles the first bundle that
4000 contains that hash, which puts that changeset back in your repository.
4002 contains that hash, which puts that changeset back in your repository.
4001
4003
4002 --verbose will print the entire commit message and the bundle path for that
4004 --verbose will print the entire commit message and the bundle path for that
4003 backup.
4005 backup.
4004 """
4006 """
4005 backups = list(
4007 backups = list(
4006 filter(
4008 filter(
4007 os.path.isfile, glob.glob(repo.vfs.join(b"strip-backup") + b"/*.hg")
4009 os.path.isfile, glob.glob(repo.vfs.join(b"strip-backup") + b"/*.hg")
4008 )
4010 )
4009 )
4011 )
4010 backups.sort(key=lambda x: os.path.getmtime(x), reverse=True)
4012 backups.sort(key=lambda x: os.path.getmtime(x), reverse=True)
4011
4013
4012 opts = pycompat.byteskwargs(opts)
4014 opts = pycompat.byteskwargs(opts)
4013 opts[b"bundle"] = b""
4015 opts[b"bundle"] = b""
4014 opts[b"force"] = None
4016 opts[b"force"] = None
4015 limit = logcmdutil.getlimit(opts)
4017 limit = logcmdutil.getlimit(opts)
4016
4018
4017 def display(other, chlist, displayer):
4019 def display(other, chlist, displayer):
4018 if opts.get(b"newest_first"):
4020 if opts.get(b"newest_first"):
4019 chlist.reverse()
4021 chlist.reverse()
4020 count = 0
4022 count = 0
4021 for n in chlist:
4023 for n in chlist:
4022 if limit is not None and count >= limit:
4024 if limit is not None and count >= limit:
4023 break
4025 break
4024 parents = [
4026 parents = [
4025 True for p in other.changelog.parents(n) if p != repo.nullid
4027 True for p in other.changelog.parents(n) if p != repo.nullid
4026 ]
4028 ]
4027 if opts.get(b"no_merges") and len(parents) == 2:
4029 if opts.get(b"no_merges") and len(parents) == 2:
4028 continue
4030 continue
4029 count += 1
4031 count += 1
4030 displayer.show(other[n])
4032 displayer.show(other[n])
4031
4033
4032 recovernode = opts.get(b"recover")
4034 recovernode = opts.get(b"recover")
4033 if recovernode:
4035 if recovernode:
4034 if scmutil.isrevsymbol(repo, recovernode):
4036 if scmutil.isrevsymbol(repo, recovernode):
4035 ui.warn(_(b"%s already exists in the repo\n") % recovernode)
4037 ui.warn(_(b"%s already exists in the repo\n") % recovernode)
4036 return
4038 return
4037 elif backups:
4039 elif backups:
4038 msg = _(
4040 msg = _(
4039 b"Recover changesets using: hg debugbackupbundle --recover "
4041 b"Recover changesets using: hg debugbackupbundle --recover "
4040 b"<changeset hash>\n\nAvailable backup changesets:"
4042 b"<changeset hash>\n\nAvailable backup changesets:"
4041 )
4043 )
4042 ui.status(msg, label=b"status.removed")
4044 ui.status(msg, label=b"status.removed")
4043 else:
4045 else:
4044 ui.status(_(b"no backup changesets found\n"))
4046 ui.status(_(b"no backup changesets found\n"))
4045 return
4047 return
4046
4048
4047 for backup in backups:
4049 for backup in backups:
4048 # Much of this is copied from the hg incoming logic
4050 # Much of this is copied from the hg incoming logic
4049 source = os.path.relpath(backup, encoding.getcwd())
4051 source = os.path.relpath(backup, encoding.getcwd())
4050 source, branches = urlutil.get_unique_pull_path(
4052 source, branches = urlutil.get_unique_pull_path(
4051 b'debugbackupbundle',
4053 b'debugbackupbundle',
4052 repo,
4054 repo,
4053 ui,
4055 ui,
4054 source,
4056 source,
4055 default_branches=opts.get(b'branch'),
4057 default_branches=opts.get(b'branch'),
4056 )
4058 )
4057 try:
4059 try:
4058 other = hg.peer(repo, opts, source)
4060 other = hg.peer(repo, opts, source)
4059 except error.LookupError as ex:
4061 except error.LookupError as ex:
4060 msg = _(b"\nwarning: unable to open bundle %s") % source
4062 msg = _(b"\nwarning: unable to open bundle %s") % source
4061 hint = _(b"\n(missing parent rev %s)\n") % short(ex.name)
4063 hint = _(b"\n(missing parent rev %s)\n") % short(ex.name)
4062 ui.warn(msg, hint=hint)
4064 ui.warn(msg, hint=hint)
4063 continue
4065 continue
4064 revs, checkout = hg.addbranchrevs(
4066 revs, checkout = hg.addbranchrevs(
4065 repo, other, branches, opts.get(b"rev")
4067 repo, other, branches, opts.get(b"rev")
4066 )
4068 )
4067
4069
4068 if revs:
4070 if revs:
4069 revs = [other.lookup(rev) for rev in revs]
4071 revs = [other.lookup(rev) for rev in revs]
4070
4072
4071 with ui.silent():
4073 with ui.silent():
4072 try:
4074 try:
4073 other, chlist, cleanupfn = bundlerepo.getremotechanges(
4075 other, chlist, cleanupfn = bundlerepo.getremotechanges(
4074 ui, repo, other, revs, opts[b"bundle"], opts[b"force"]
4076 ui, repo, other, revs, opts[b"bundle"], opts[b"force"]
4075 )
4077 )
4076 except error.LookupError:
4078 except error.LookupError:
4077 continue
4079 continue
4078
4080
4079 try:
4081 try:
4080 if not chlist:
4082 if not chlist:
4081 continue
4083 continue
4082 if recovernode:
4084 if recovernode:
4083 with repo.lock(), repo.transaction(b"unbundle") as tr:
4085 with repo.lock(), repo.transaction(b"unbundle") as tr:
4084 if scmutil.isrevsymbol(other, recovernode):
4086 if scmutil.isrevsymbol(other, recovernode):
4085 ui.status(_(b"Unbundling %s\n") % (recovernode))
4087 ui.status(_(b"Unbundling %s\n") % (recovernode))
4086 f = hg.openpath(ui, source)
4088 f = hg.openpath(ui, source)
4087 gen = exchange.readbundle(ui, f, source)
4089 gen = exchange.readbundle(ui, f, source)
4088 if isinstance(gen, bundle2.unbundle20):
4090 if isinstance(gen, bundle2.unbundle20):
4089 bundle2.applybundle(
4091 bundle2.applybundle(
4090 repo,
4092 repo,
4091 gen,
4093 gen,
4092 tr,
4094 tr,
4093 source=b"unbundle",
4095 source=b"unbundle",
4094 url=b"bundle:" + source,
4096 url=b"bundle:" + source,
4095 )
4097 )
4096 else:
4098 else:
4097 gen.apply(repo, b"unbundle", b"bundle:" + source)
4099 gen.apply(repo, b"unbundle", b"bundle:" + source)
4098 break
4100 break
4099 else:
4101 else:
4100 backupdate = encoding.strtolocal(
4102 backupdate = encoding.strtolocal(
4101 time.strftime(
4103 time.strftime(
4102 "%a %H:%M, %Y-%m-%d",
4104 "%a %H:%M, %Y-%m-%d",
4103 time.localtime(os.path.getmtime(source)),
4105 time.localtime(os.path.getmtime(source)),
4104 )
4106 )
4105 )
4107 )
4106 ui.status(b"\n%s\n" % (backupdate.ljust(50)))
4108 ui.status(b"\n%s\n" % (backupdate.ljust(50)))
4107 if ui.verbose:
4109 if ui.verbose:
4108 ui.status(b"%s%s\n" % (b"bundle:".ljust(13), source))
4110 ui.status(b"%s%s\n" % (b"bundle:".ljust(13), source))
4109 else:
4111 else:
4110 opts[
4112 opts[
4111 b"template"
4113 b"template"
4112 ] = b"{label('status.modified', node|short)} {desc|firstline}\n"
4114 ] = b"{label('status.modified', node|short)} {desc|firstline}\n"
4113 displayer = logcmdutil.changesetdisplayer(
4115 displayer = logcmdutil.changesetdisplayer(
4114 ui, other, opts, False
4116 ui, other, opts, False
4115 )
4117 )
4116 display(other, chlist, displayer)
4118 display(other, chlist, displayer)
4117 displayer.close()
4119 displayer.close()
4118 finally:
4120 finally:
4119 cleanupfn()
4121 cleanupfn()
4120
4122
4121
4123
4122 @command(
4124 @command(
4123 b'debugsub',
4125 b'debugsub',
4124 [(b'r', b'rev', b'', _(b'revision to check'), _(b'REV'))],
4126 [(b'r', b'rev', b'', _(b'revision to check'), _(b'REV'))],
4125 _(b'[-r REV] [REV]'),
4127 _(b'[-r REV] [REV]'),
4126 )
4128 )
4127 def debugsub(ui, repo, rev=None):
4129 def debugsub(ui, repo, rev=None):
4128 ctx = scmutil.revsingle(repo, rev, None)
4130 ctx = scmutil.revsingle(repo, rev, None)
4129 for k, v in sorted(ctx.substate.items()):
4131 for k, v in sorted(ctx.substate.items()):
4130 ui.writenoi18n(b'path %s\n' % k)
4132 ui.writenoi18n(b'path %s\n' % k)
4131 ui.writenoi18n(b' source %s\n' % v[0])
4133 ui.writenoi18n(b' source %s\n' % v[0])
4132 ui.writenoi18n(b' revision %s\n' % v[1])
4134 ui.writenoi18n(b' revision %s\n' % v[1])
4133
4135
4134
4136
4135 @command(b'debugshell', optionalrepo=True)
4137 @command(b'debugshell', optionalrepo=True)
4136 def debugshell(ui, repo):
4138 def debugshell(ui, repo):
4137 """run an interactive Python interpreter
4139 """run an interactive Python interpreter
4138
4140
4139 The local namespace is provided with a reference to the ui and
4141 The local namespace is provided with a reference to the ui and
4140 the repo instance (if available).
4142 the repo instance (if available).
4141 """
4143 """
4142 import code
4144 import code
4143
4145
4144 imported_objects = {
4146 imported_objects = {
4145 'ui': ui,
4147 'ui': ui,
4146 'repo': repo,
4148 'repo': repo,
4147 }
4149 }
4148
4150
4149 code.interact(local=imported_objects)
4151 code.interact(local=imported_objects)
4150
4152
4151
4153
4152 @command(
4154 @command(
4153 b'debugsuccessorssets',
4155 b'debugsuccessorssets',
4154 [(b'', b'closest', False, _(b'return closest successors sets only'))],
4156 [(b'', b'closest', False, _(b'return closest successors sets only'))],
4155 _(b'[REV]'),
4157 _(b'[REV]'),
4156 )
4158 )
4157 def debugsuccessorssets(ui, repo, *revs, **opts):
4159 def debugsuccessorssets(ui, repo, *revs, **opts):
4158 """show set of successors for revision
4160 """show set of successors for revision
4159
4161
4160 A successors set of changeset A is a consistent group of revisions that
4162 A successors set of changeset A is a consistent group of revisions that
4161 succeed A. It contains non-obsolete changesets only unless closests
4163 succeed A. It contains non-obsolete changesets only unless closests
4162 successors set is set.
4164 successors set is set.
4163
4165
4164 In most cases a changeset A has a single successors set containing a single
4166 In most cases a changeset A has a single successors set containing a single
4165 successor (changeset A replaced by A').
4167 successor (changeset A replaced by A').
4166
4168
4167 A changeset that is made obsolete with no successors are called "pruned".
4169 A changeset that is made obsolete with no successors are called "pruned".
4168 Such changesets have no successors sets at all.
4170 Such changesets have no successors sets at all.
4169
4171
4170 A changeset that has been "split" will have a successors set containing
4172 A changeset that has been "split" will have a successors set containing
4171 more than one successor.
4173 more than one successor.
4172
4174
4173 A changeset that has been rewritten in multiple different ways is called
4175 A changeset that has been rewritten in multiple different ways is called
4174 "divergent". Such changesets have multiple successor sets (each of which
4176 "divergent". Such changesets have multiple successor sets (each of which
4175 may also be split, i.e. have multiple successors).
4177 may also be split, i.e. have multiple successors).
4176
4178
4177 Results are displayed as follows::
4179 Results are displayed as follows::
4178
4180
4179 <rev1>
4181 <rev1>
4180 <successors-1A>
4182 <successors-1A>
4181 <rev2>
4183 <rev2>
4182 <successors-2A>
4184 <successors-2A>
4183 <successors-2B1> <successors-2B2> <successors-2B3>
4185 <successors-2B1> <successors-2B2> <successors-2B3>
4184
4186
4185 Here rev2 has two possible (i.e. divergent) successors sets. The first
4187 Here rev2 has two possible (i.e. divergent) successors sets. The first
4186 holds one element, whereas the second holds three (i.e. the changeset has
4188 holds one element, whereas the second holds three (i.e. the changeset has
4187 been split).
4189 been split).
4188 """
4190 """
4189 # passed to successorssets caching computation from one call to another
4191 # passed to successorssets caching computation from one call to another
4190 cache = {}
4192 cache = {}
4191 ctx2str = bytes
4193 ctx2str = bytes
4192 node2str = short
4194 node2str = short
4193 for rev in logcmdutil.revrange(repo, revs):
4195 for rev in logcmdutil.revrange(repo, revs):
4194 ctx = repo[rev]
4196 ctx = repo[rev]
4195 ui.write(b'%s\n' % ctx2str(ctx))
4197 ui.write(b'%s\n' % ctx2str(ctx))
4196 for succsset in obsutil.successorssets(
4198 for succsset in obsutil.successorssets(
4197 repo, ctx.node(), closest=opts['closest'], cache=cache
4199 repo, ctx.node(), closest=opts['closest'], cache=cache
4198 ):
4200 ):
4199 if succsset:
4201 if succsset:
4200 ui.write(b' ')
4202 ui.write(b' ')
4201 ui.write(node2str(succsset[0]))
4203 ui.write(node2str(succsset[0]))
4202 for node in succsset[1:]:
4204 for node in succsset[1:]:
4203 ui.write(b' ')
4205 ui.write(b' ')
4204 ui.write(node2str(node))
4206 ui.write(node2str(node))
4205 ui.write(b'\n')
4207 ui.write(b'\n')
4206
4208
4207
4209
4208 @command(b'debugtagscache', [])
4210 @command(b'debugtagscache', [])
4209 def debugtagscache(ui, repo):
4211 def debugtagscache(ui, repo):
4210 """display the contents of .hg/cache/hgtagsfnodes1"""
4212 """display the contents of .hg/cache/hgtagsfnodes1"""
4211 cache = tagsmod.hgtagsfnodescache(repo.unfiltered())
4213 cache = tagsmod.hgtagsfnodescache(repo.unfiltered())
4212 flog = repo.file(b'.hgtags')
4214 flog = repo.file(b'.hgtags')
4213 for r in repo:
4215 for r in repo:
4214 node = repo[r].node()
4216 node = repo[r].node()
4215 tagsnode = cache.getfnode(node, computemissing=False)
4217 tagsnode = cache.getfnode(node, computemissing=False)
4216 if tagsnode:
4218 if tagsnode:
4217 tagsnodedisplay = hex(tagsnode)
4219 tagsnodedisplay = hex(tagsnode)
4218 if not flog.hasnode(tagsnode):
4220 if not flog.hasnode(tagsnode):
4219 tagsnodedisplay += b' (unknown node)'
4221 tagsnodedisplay += b' (unknown node)'
4220 elif tagsnode is None:
4222 elif tagsnode is None:
4221 tagsnodedisplay = b'missing'
4223 tagsnodedisplay = b'missing'
4222 else:
4224 else:
4223 tagsnodedisplay = b'invalid'
4225 tagsnodedisplay = b'invalid'
4224
4226
4225 ui.write(b'%d %s %s\n' % (r, hex(node), tagsnodedisplay))
4227 ui.write(b'%d %s %s\n' % (r, hex(node), tagsnodedisplay))
4226
4228
4227
4229
4228 @command(
4230 @command(
4229 b'debugtemplate',
4231 b'debugtemplate',
4230 [
4232 [
4231 (b'r', b'rev', [], _(b'apply template on changesets'), _(b'REV')),
4233 (b'r', b'rev', [], _(b'apply template on changesets'), _(b'REV')),
4232 (b'D', b'define', [], _(b'define template keyword'), _(b'KEY=VALUE')),
4234 (b'D', b'define', [], _(b'define template keyword'), _(b'KEY=VALUE')),
4233 ],
4235 ],
4234 _(b'[-r REV]... [-D KEY=VALUE]... TEMPLATE'),
4236 _(b'[-r REV]... [-D KEY=VALUE]... TEMPLATE'),
4235 optionalrepo=True,
4237 optionalrepo=True,
4236 )
4238 )
4237 def debugtemplate(ui, repo, tmpl, **opts):
4239 def debugtemplate(ui, repo, tmpl, **opts):
4238 """parse and apply a template
4240 """parse and apply a template
4239
4241
4240 If -r/--rev is given, the template is processed as a log template and
4242 If -r/--rev is given, the template is processed as a log template and
4241 applied to the given changesets. Otherwise, it is processed as a generic
4243 applied to the given changesets. Otherwise, it is processed as a generic
4242 template.
4244 template.
4243
4245
4244 Use --verbose to print the parsed tree.
4246 Use --verbose to print the parsed tree.
4245 """
4247 """
4246 revs = None
4248 revs = None
4247 if opts['rev']:
4249 if opts['rev']:
4248 if repo is None:
4250 if repo is None:
4249 raise error.RepoError(
4251 raise error.RepoError(
4250 _(b'there is no Mercurial repository here (.hg not found)')
4252 _(b'there is no Mercurial repository here (.hg not found)')
4251 )
4253 )
4252 revs = logcmdutil.revrange(repo, opts['rev'])
4254 revs = logcmdutil.revrange(repo, opts['rev'])
4253
4255
4254 props = {}
4256 props = {}
4255 for d in opts['define']:
4257 for d in opts['define']:
4256 try:
4258 try:
4257 k, v = (e.strip() for e in d.split(b'=', 1))
4259 k, v = (e.strip() for e in d.split(b'=', 1))
4258 if not k or k == b'ui':
4260 if not k or k == b'ui':
4259 raise ValueError
4261 raise ValueError
4260 props[k] = v
4262 props[k] = v
4261 except ValueError:
4263 except ValueError:
4262 raise error.Abort(_(b'malformed keyword definition: %s') % d)
4264 raise error.Abort(_(b'malformed keyword definition: %s') % d)
4263
4265
4264 if ui.verbose:
4266 if ui.verbose:
4265 aliases = ui.configitems(b'templatealias')
4267 aliases = ui.configitems(b'templatealias')
4266 tree = templater.parse(tmpl)
4268 tree = templater.parse(tmpl)
4267 ui.note(templater.prettyformat(tree), b'\n')
4269 ui.note(templater.prettyformat(tree), b'\n')
4268 newtree = templater.expandaliases(tree, aliases)
4270 newtree = templater.expandaliases(tree, aliases)
4269 if newtree != tree:
4271 if newtree != tree:
4270 ui.notenoi18n(
4272 ui.notenoi18n(
4271 b"* expanded:\n", templater.prettyformat(newtree), b'\n'
4273 b"* expanded:\n", templater.prettyformat(newtree), b'\n'
4272 )
4274 )
4273
4275
4274 if revs is None:
4276 if revs is None:
4275 tres = formatter.templateresources(ui, repo)
4277 tres = formatter.templateresources(ui, repo)
4276 t = formatter.maketemplater(ui, tmpl, resources=tres)
4278 t = formatter.maketemplater(ui, tmpl, resources=tres)
4277 if ui.verbose:
4279 if ui.verbose:
4278 kwds, funcs = t.symbolsuseddefault()
4280 kwds, funcs = t.symbolsuseddefault()
4279 ui.writenoi18n(b"* keywords: %s\n" % b', '.join(sorted(kwds)))
4281 ui.writenoi18n(b"* keywords: %s\n" % b', '.join(sorted(kwds)))
4280 ui.writenoi18n(b"* functions: %s\n" % b', '.join(sorted(funcs)))
4282 ui.writenoi18n(b"* functions: %s\n" % b', '.join(sorted(funcs)))
4281 ui.write(t.renderdefault(props))
4283 ui.write(t.renderdefault(props))
4282 else:
4284 else:
4283 displayer = logcmdutil.maketemplater(ui, repo, tmpl)
4285 displayer = logcmdutil.maketemplater(ui, repo, tmpl)
4284 if ui.verbose:
4286 if ui.verbose:
4285 kwds, funcs = displayer.t.symbolsuseddefault()
4287 kwds, funcs = displayer.t.symbolsuseddefault()
4286 ui.writenoi18n(b"* keywords: %s\n" % b', '.join(sorted(kwds)))
4288 ui.writenoi18n(b"* keywords: %s\n" % b', '.join(sorted(kwds)))
4287 ui.writenoi18n(b"* functions: %s\n" % b', '.join(sorted(funcs)))
4289 ui.writenoi18n(b"* functions: %s\n" % b', '.join(sorted(funcs)))
4288 for r in revs:
4290 for r in revs:
4289 displayer.show(repo[r], **pycompat.strkwargs(props))
4291 displayer.show(repo[r], **pycompat.strkwargs(props))
4290 displayer.close()
4292 displayer.close()
4291
4293
4292
4294
4293 @command(
4295 @command(
4294 b'debuguigetpass',
4296 b'debuguigetpass',
4295 [
4297 [
4296 (b'p', b'prompt', b'', _(b'prompt text'), _(b'TEXT')),
4298 (b'p', b'prompt', b'', _(b'prompt text'), _(b'TEXT')),
4297 ],
4299 ],
4298 _(b'[-p TEXT]'),
4300 _(b'[-p TEXT]'),
4299 norepo=True,
4301 norepo=True,
4300 )
4302 )
4301 def debuguigetpass(ui, prompt=b''):
4303 def debuguigetpass(ui, prompt=b''):
4302 """show prompt to type password"""
4304 """show prompt to type password"""
4303 r = ui.getpass(prompt)
4305 r = ui.getpass(prompt)
4304 if r is None:
4306 if r is None:
4305 r = b"<default response>"
4307 r = b"<default response>"
4306 ui.writenoi18n(b'response: %s\n' % r)
4308 ui.writenoi18n(b'response: %s\n' % r)
4307
4309
4308
4310
4309 @command(
4311 @command(
4310 b'debuguiprompt',
4312 b'debuguiprompt',
4311 [
4313 [
4312 (b'p', b'prompt', b'', _(b'prompt text'), _(b'TEXT')),
4314 (b'p', b'prompt', b'', _(b'prompt text'), _(b'TEXT')),
4313 ],
4315 ],
4314 _(b'[-p TEXT]'),
4316 _(b'[-p TEXT]'),
4315 norepo=True,
4317 norepo=True,
4316 )
4318 )
4317 def debuguiprompt(ui, prompt=b''):
4319 def debuguiprompt(ui, prompt=b''):
4318 """show plain prompt"""
4320 """show plain prompt"""
4319 r = ui.prompt(prompt)
4321 r = ui.prompt(prompt)
4320 ui.writenoi18n(b'response: %s\n' % r)
4322 ui.writenoi18n(b'response: %s\n' % r)
4321
4323
4322
4324
4323 @command(b'debugupdatecaches', [])
4325 @command(b'debugupdatecaches', [])
4324 def debugupdatecaches(ui, repo, *pats, **opts):
4326 def debugupdatecaches(ui, repo, *pats, **opts):
4325 """warm all known caches in the repository"""
4327 """warm all known caches in the repository"""
4326 with repo.wlock(), repo.lock():
4328 with repo.wlock(), repo.lock():
4327 repo.updatecaches(caches=repository.CACHES_ALL)
4329 repo.updatecaches(caches=repository.CACHES_ALL)
4328
4330
4329
4331
4330 @command(
4332 @command(
4331 b'debugupgraderepo',
4333 b'debugupgraderepo',
4332 [
4334 [
4333 (
4335 (
4334 b'o',
4336 b'o',
4335 b'optimize',
4337 b'optimize',
4336 [],
4338 [],
4337 _(b'extra optimization to perform'),
4339 _(b'extra optimization to perform'),
4338 _(b'NAME'),
4340 _(b'NAME'),
4339 ),
4341 ),
4340 (b'', b'run', False, _(b'performs an upgrade')),
4342 (b'', b'run', False, _(b'performs an upgrade')),
4341 (b'', b'backup', True, _(b'keep the old repository content around')),
4343 (b'', b'backup', True, _(b'keep the old repository content around')),
4342 (b'', b'changelog', None, _(b'select the changelog for upgrade')),
4344 (b'', b'changelog', None, _(b'select the changelog for upgrade')),
4343 (b'', b'manifest', None, _(b'select the manifest for upgrade')),
4345 (b'', b'manifest', None, _(b'select the manifest for upgrade')),
4344 (b'', b'filelogs', None, _(b'select all filelogs for upgrade')),
4346 (b'', b'filelogs', None, _(b'select all filelogs for upgrade')),
4345 ],
4347 ],
4346 )
4348 )
4347 def debugupgraderepo(ui, repo, run=False, optimize=None, backup=True, **opts):
4349 def debugupgraderepo(ui, repo, run=False, optimize=None, backup=True, **opts):
4348 """upgrade a repository to use different features
4350 """upgrade a repository to use different features
4349
4351
4350 If no arguments are specified, the repository is evaluated for upgrade
4352 If no arguments are specified, the repository is evaluated for upgrade
4351 and a list of problems and potential optimizations is printed.
4353 and a list of problems and potential optimizations is printed.
4352
4354
4353 With ``--run``, a repository upgrade is performed. Behavior of the upgrade
4355 With ``--run``, a repository upgrade is performed. Behavior of the upgrade
4354 can be influenced via additional arguments. More details will be provided
4356 can be influenced via additional arguments. More details will be provided
4355 by the command output when run without ``--run``.
4357 by the command output when run without ``--run``.
4356
4358
4357 During the upgrade, the repository will be locked and no writes will be
4359 During the upgrade, the repository will be locked and no writes will be
4358 allowed.
4360 allowed.
4359
4361
4360 At the end of the upgrade, the repository may not be readable while new
4362 At the end of the upgrade, the repository may not be readable while new
4361 repository data is swapped in. This window will be as long as it takes to
4363 repository data is swapped in. This window will be as long as it takes to
4362 rename some directories inside the ``.hg`` directory. On most machines, this
4364 rename some directories inside the ``.hg`` directory. On most machines, this
4363 should complete almost instantaneously and the chances of a consumer being
4365 should complete almost instantaneously and the chances of a consumer being
4364 unable to access the repository should be low.
4366 unable to access the repository should be low.
4365
4367
4366 By default, all revlogs will be upgraded. You can restrict this using flags
4368 By default, all revlogs will be upgraded. You can restrict this using flags
4367 such as `--manifest`:
4369 such as `--manifest`:
4368
4370
4369 * `--manifest`: only optimize the manifest
4371 * `--manifest`: only optimize the manifest
4370 * `--no-manifest`: optimize all revlog but the manifest
4372 * `--no-manifest`: optimize all revlog but the manifest
4371 * `--changelog`: optimize the changelog only
4373 * `--changelog`: optimize the changelog only
4372 * `--no-changelog --no-manifest`: optimize filelogs only
4374 * `--no-changelog --no-manifest`: optimize filelogs only
4373 * `--filelogs`: optimize the filelogs only
4375 * `--filelogs`: optimize the filelogs only
4374 * `--no-changelog --no-manifest --no-filelogs`: skip all revlog optimizations
4376 * `--no-changelog --no-manifest --no-filelogs`: skip all revlog optimizations
4375 """
4377 """
4376 return upgrade.upgraderepo(
4378 return upgrade.upgraderepo(
4377 ui, repo, run=run, optimize=set(optimize), backup=backup, **opts
4379 ui, repo, run=run, optimize=set(optimize), backup=backup, **opts
4378 )
4380 )
4379
4381
4380
4382
4381 @command(
4383 @command(
4382 b'debugwalk', cmdutil.walkopts, _(b'[OPTION]... [FILE]...'), inferrepo=True
4384 b'debugwalk', cmdutil.walkopts, _(b'[OPTION]... [FILE]...'), inferrepo=True
4383 )
4385 )
4384 def debugwalk(ui, repo, *pats, **opts):
4386 def debugwalk(ui, repo, *pats, **opts):
4385 """show how files match on given patterns"""
4387 """show how files match on given patterns"""
4386 opts = pycompat.byteskwargs(opts)
4388 opts = pycompat.byteskwargs(opts)
4387 m = scmutil.match(repo[None], pats, opts)
4389 m = scmutil.match(repo[None], pats, opts)
4388 if ui.verbose:
4390 if ui.verbose:
4389 ui.writenoi18n(b'* matcher:\n', stringutil.prettyrepr(m), b'\n')
4391 ui.writenoi18n(b'* matcher:\n', stringutil.prettyrepr(m), b'\n')
4390 items = list(repo[None].walk(m))
4392 items = list(repo[None].walk(m))
4391 if not items:
4393 if not items:
4392 return
4394 return
4393 f = lambda fn: fn
4395 f = lambda fn: fn
4394 if ui.configbool(b'ui', b'slash') and pycompat.ossep != b'/':
4396 if ui.configbool(b'ui', b'slash') and pycompat.ossep != b'/':
4395 f = lambda fn: util.normpath(fn)
4397 f = lambda fn: util.normpath(fn)
4396 fmt = b'f %%-%ds %%-%ds %%s' % (
4398 fmt = b'f %%-%ds %%-%ds %%s' % (
4397 max([len(abs) for abs in items]),
4399 max([len(abs) for abs in items]),
4398 max([len(repo.pathto(abs)) for abs in items]),
4400 max([len(repo.pathto(abs)) for abs in items]),
4399 )
4401 )
4400 for abs in items:
4402 for abs in items:
4401 line = fmt % (
4403 line = fmt % (
4402 abs,
4404 abs,
4403 f(repo.pathto(abs)),
4405 f(repo.pathto(abs)),
4404 m.exact(abs) and b'exact' or b'',
4406 m.exact(abs) and b'exact' or b'',
4405 )
4407 )
4406 ui.write(b"%s\n" % line.rstrip())
4408 ui.write(b"%s\n" % line.rstrip())
4407
4409
4408
4410
4409 @command(b'debugwhyunstable', [], _(b'REV'))
4411 @command(b'debugwhyunstable', [], _(b'REV'))
4410 def debugwhyunstable(ui, repo, rev):
4412 def debugwhyunstable(ui, repo, rev):
4411 """explain instabilities of a changeset"""
4413 """explain instabilities of a changeset"""
4412 for entry in obsutil.whyunstable(repo, scmutil.revsingle(repo, rev)):
4414 for entry in obsutil.whyunstable(repo, scmutil.revsingle(repo, rev)):
4413 dnodes = b''
4415 dnodes = b''
4414 if entry.get(b'divergentnodes'):
4416 if entry.get(b'divergentnodes'):
4415 dnodes = (
4417 dnodes = (
4416 b' '.join(
4418 b' '.join(
4417 b'%s (%s)' % (ctx.hex(), ctx.phasestr())
4419 b'%s (%s)' % (ctx.hex(), ctx.phasestr())
4418 for ctx in entry[b'divergentnodes']
4420 for ctx in entry[b'divergentnodes']
4419 )
4421 )
4420 + b' '
4422 + b' '
4421 )
4423 )
4422 ui.write(
4424 ui.write(
4423 b'%s: %s%s %s\n'
4425 b'%s: %s%s %s\n'
4424 % (entry[b'instability'], dnodes, entry[b'reason'], entry[b'node'])
4426 % (entry[b'instability'], dnodes, entry[b'reason'], entry[b'node'])
4425 )
4427 )
4426
4428
4427
4429
4428 @command(
4430 @command(
4429 b'debugwireargs',
4431 b'debugwireargs',
4430 [
4432 [
4431 (b'', b'three', b'', b'three'),
4433 (b'', b'three', b'', b'three'),
4432 (b'', b'four', b'', b'four'),
4434 (b'', b'four', b'', b'four'),
4433 (b'', b'five', b'', b'five'),
4435 (b'', b'five', b'', b'five'),
4434 ]
4436 ]
4435 + cmdutil.remoteopts,
4437 + cmdutil.remoteopts,
4436 _(b'REPO [OPTIONS]... [ONE [TWO]]'),
4438 _(b'REPO [OPTIONS]... [ONE [TWO]]'),
4437 norepo=True,
4439 norepo=True,
4438 )
4440 )
4439 def debugwireargs(ui, repopath, *vals, **opts):
4441 def debugwireargs(ui, repopath, *vals, **opts):
4440 opts = pycompat.byteskwargs(opts)
4442 opts = pycompat.byteskwargs(opts)
4441 repo = hg.peer(ui, opts, repopath)
4443 repo = hg.peer(ui, opts, repopath)
4442 try:
4444 try:
4443 for opt in cmdutil.remoteopts:
4445 for opt in cmdutil.remoteopts:
4444 del opts[opt[1]]
4446 del opts[opt[1]]
4445 args = {}
4447 args = {}
4446 for k, v in opts.items():
4448 for k, v in opts.items():
4447 if v:
4449 if v:
4448 args[k] = v
4450 args[k] = v
4449 args = pycompat.strkwargs(args)
4451 args = pycompat.strkwargs(args)
4450 # run twice to check that we don't mess up the stream for the next command
4452 # run twice to check that we don't mess up the stream for the next command
4451 res1 = repo.debugwireargs(*vals, **args)
4453 res1 = repo.debugwireargs(*vals, **args)
4452 res2 = repo.debugwireargs(*vals, **args)
4454 res2 = repo.debugwireargs(*vals, **args)
4453 ui.write(b"%s\n" % res1)
4455 ui.write(b"%s\n" % res1)
4454 if res1 != res2:
4456 if res1 != res2:
4455 ui.warn(b"%s\n" % res2)
4457 ui.warn(b"%s\n" % res2)
4456 finally:
4458 finally:
4457 repo.close()
4459 repo.close()
4458
4460
4459
4461
4460 def _parsewirelangblocks(fh):
4462 def _parsewirelangblocks(fh):
4461 activeaction = None
4463 activeaction = None
4462 blocklines = []
4464 blocklines = []
4463 lastindent = 0
4465 lastindent = 0
4464
4466
4465 for line in fh:
4467 for line in fh:
4466 line = line.rstrip()
4468 line = line.rstrip()
4467 if not line:
4469 if not line:
4468 continue
4470 continue
4469
4471
4470 if line.startswith(b'#'):
4472 if line.startswith(b'#'):
4471 continue
4473 continue
4472
4474
4473 if not line.startswith(b' '):
4475 if not line.startswith(b' '):
4474 # New block. Flush previous one.
4476 # New block. Flush previous one.
4475 if activeaction:
4477 if activeaction:
4476 yield activeaction, blocklines
4478 yield activeaction, blocklines
4477
4479
4478 activeaction = line
4480 activeaction = line
4479 blocklines = []
4481 blocklines = []
4480 lastindent = 0
4482 lastindent = 0
4481 continue
4483 continue
4482
4484
4483 # Else we start with an indent.
4485 # Else we start with an indent.
4484
4486
4485 if not activeaction:
4487 if not activeaction:
4486 raise error.Abort(_(b'indented line outside of block'))
4488 raise error.Abort(_(b'indented line outside of block'))
4487
4489
4488 indent = len(line) - len(line.lstrip())
4490 indent = len(line) - len(line.lstrip())
4489
4491
4490 # If this line is indented more than the last line, concatenate it.
4492 # If this line is indented more than the last line, concatenate it.
4491 if indent > lastindent and blocklines:
4493 if indent > lastindent and blocklines:
4492 blocklines[-1] += line.lstrip()
4494 blocklines[-1] += line.lstrip()
4493 else:
4495 else:
4494 blocklines.append(line)
4496 blocklines.append(line)
4495 lastindent = indent
4497 lastindent = indent
4496
4498
4497 # Flush last block.
4499 # Flush last block.
4498 if activeaction:
4500 if activeaction:
4499 yield activeaction, blocklines
4501 yield activeaction, blocklines
4500
4502
4501
4503
4502 @command(
4504 @command(
4503 b'debugwireproto',
4505 b'debugwireproto',
4504 [
4506 [
4505 (b'', b'localssh', False, _(b'start an SSH server for this repo')),
4507 (b'', b'localssh', False, _(b'start an SSH server for this repo')),
4506 (b'', b'peer', b'', _(b'construct a specific version of the peer')),
4508 (b'', b'peer', b'', _(b'construct a specific version of the peer')),
4507 (
4509 (
4508 b'',
4510 b'',
4509 b'noreadstderr',
4511 b'noreadstderr',
4510 False,
4512 False,
4511 _(b'do not read from stderr of the remote'),
4513 _(b'do not read from stderr of the remote'),
4512 ),
4514 ),
4513 (
4515 (
4514 b'',
4516 b'',
4515 b'nologhandshake',
4517 b'nologhandshake',
4516 False,
4518 False,
4517 _(b'do not log I/O related to the peer handshake'),
4519 _(b'do not log I/O related to the peer handshake'),
4518 ),
4520 ),
4519 ]
4521 ]
4520 + cmdutil.remoteopts,
4522 + cmdutil.remoteopts,
4521 _(b'[PATH]'),
4523 _(b'[PATH]'),
4522 optionalrepo=True,
4524 optionalrepo=True,
4523 )
4525 )
4524 def debugwireproto(ui, repo, path=None, **opts):
4526 def debugwireproto(ui, repo, path=None, **opts):
4525 """send wire protocol commands to a server
4527 """send wire protocol commands to a server
4526
4528
4527 This command can be used to issue wire protocol commands to remote
4529 This command can be used to issue wire protocol commands to remote
4528 peers and to debug the raw data being exchanged.
4530 peers and to debug the raw data being exchanged.
4529
4531
4530 ``--localssh`` will start an SSH server against the current repository
4532 ``--localssh`` will start an SSH server against the current repository
4531 and connect to that. By default, the connection will perform a handshake
4533 and connect to that. By default, the connection will perform a handshake
4532 and establish an appropriate peer instance.
4534 and establish an appropriate peer instance.
4533
4535
4534 ``--peer`` can be used to bypass the handshake protocol and construct a
4536 ``--peer`` can be used to bypass the handshake protocol and construct a
4535 peer instance using the specified class type. Valid values are ``raw``,
4537 peer instance using the specified class type. Valid values are ``raw``,
4536 ``ssh1``. ``raw`` instances only allow sending raw data payloads and
4538 ``ssh1``. ``raw`` instances only allow sending raw data payloads and
4537 don't support higher-level command actions.
4539 don't support higher-level command actions.
4538
4540
4539 ``--noreadstderr`` can be used to disable automatic reading from stderr
4541 ``--noreadstderr`` can be used to disable automatic reading from stderr
4540 of the peer (for SSH connections only). Disabling automatic reading of
4542 of the peer (for SSH connections only). Disabling automatic reading of
4541 stderr is useful for making output more deterministic.
4543 stderr is useful for making output more deterministic.
4542
4544
4543 Commands are issued via a mini language which is specified via stdin.
4545 Commands are issued via a mini language which is specified via stdin.
4544 The language consists of individual actions to perform. An action is
4546 The language consists of individual actions to perform. An action is
4545 defined by a block. A block is defined as a line with no leading
4547 defined by a block. A block is defined as a line with no leading
4546 space followed by 0 or more lines with leading space. Blocks are
4548 space followed by 0 or more lines with leading space. Blocks are
4547 effectively a high-level command with additional metadata.
4549 effectively a high-level command with additional metadata.
4548
4550
4549 Lines beginning with ``#`` are ignored.
4551 Lines beginning with ``#`` are ignored.
4550
4552
4551 The following sections denote available actions.
4553 The following sections denote available actions.
4552
4554
4553 raw
4555 raw
4554 ---
4556 ---
4555
4557
4556 Send raw data to the server.
4558 Send raw data to the server.
4557
4559
4558 The block payload contains the raw data to send as one atomic send
4560 The block payload contains the raw data to send as one atomic send
4559 operation. The data may not actually be delivered in a single system
4561 operation. The data may not actually be delivered in a single system
4560 call: it depends on the abilities of the transport being used.
4562 call: it depends on the abilities of the transport being used.
4561
4563
4562 Each line in the block is de-indented and concatenated. Then, that
4564 Each line in the block is de-indented and concatenated. Then, that
4563 value is evaluated as a Python b'' literal. This allows the use of
4565 value is evaluated as a Python b'' literal. This allows the use of
4564 backslash escaping, etc.
4566 backslash escaping, etc.
4565
4567
4566 raw+
4568 raw+
4567 ----
4569 ----
4568
4570
4569 Behaves like ``raw`` except flushes output afterwards.
4571 Behaves like ``raw`` except flushes output afterwards.
4570
4572
4571 command <X>
4573 command <X>
4572 -----------
4574 -----------
4573
4575
4574 Send a request to run a named command, whose name follows the ``command``
4576 Send a request to run a named command, whose name follows the ``command``
4575 string.
4577 string.
4576
4578
4577 Arguments to the command are defined as lines in this block. The format of
4579 Arguments to the command are defined as lines in this block. The format of
4578 each line is ``<key> <value>``. e.g.::
4580 each line is ``<key> <value>``. e.g.::
4579
4581
4580 command listkeys
4582 command listkeys
4581 namespace bookmarks
4583 namespace bookmarks
4582
4584
4583 If the value begins with ``eval:``, it will be interpreted as a Python
4585 If the value begins with ``eval:``, it will be interpreted as a Python
4584 literal expression. Otherwise values are interpreted as Python b'' literals.
4586 literal expression. Otherwise values are interpreted as Python b'' literals.
4585 This allows sending complex types and encoding special byte sequences via
4587 This allows sending complex types and encoding special byte sequences via
4586 backslash escaping.
4588 backslash escaping.
4587
4589
4588 The following arguments have special meaning:
4590 The following arguments have special meaning:
4589
4591
4590 ``PUSHFILE``
4592 ``PUSHFILE``
4591 When defined, the *push* mechanism of the peer will be used instead
4593 When defined, the *push* mechanism of the peer will be used instead
4592 of the static request-response mechanism and the content of the
4594 of the static request-response mechanism and the content of the
4593 file specified in the value of this argument will be sent as the
4595 file specified in the value of this argument will be sent as the
4594 command payload.
4596 command payload.
4595
4597
4596 This can be used to submit a local bundle file to the remote.
4598 This can be used to submit a local bundle file to the remote.
4597
4599
4598 batchbegin
4600 batchbegin
4599 ----------
4601 ----------
4600
4602
4601 Instruct the peer to begin a batched send.
4603 Instruct the peer to begin a batched send.
4602
4604
4603 All ``command`` blocks are queued for execution until the next
4605 All ``command`` blocks are queued for execution until the next
4604 ``batchsubmit`` block.
4606 ``batchsubmit`` block.
4605
4607
4606 batchsubmit
4608 batchsubmit
4607 -----------
4609 -----------
4608
4610
4609 Submit previously queued ``command`` blocks as a batch request.
4611 Submit previously queued ``command`` blocks as a batch request.
4610
4612
4611 This action MUST be paired with a ``batchbegin`` action.
4613 This action MUST be paired with a ``batchbegin`` action.
4612
4614
4613 httprequest <method> <path>
4615 httprequest <method> <path>
4614 ---------------------------
4616 ---------------------------
4615
4617
4616 (HTTP peer only)
4618 (HTTP peer only)
4617
4619
4618 Send an HTTP request to the peer.
4620 Send an HTTP request to the peer.
4619
4621
4620 The HTTP request line follows the ``httprequest`` action. e.g. ``GET /foo``.
4622 The HTTP request line follows the ``httprequest`` action. e.g. ``GET /foo``.
4621
4623
4622 Arguments of the form ``<key>: <value>`` are interpreted as HTTP request
4624 Arguments of the form ``<key>: <value>`` are interpreted as HTTP request
4623 headers to add to the request. e.g. ``Accept: foo``.
4625 headers to add to the request. e.g. ``Accept: foo``.
4624
4626
4625 The following arguments are special:
4627 The following arguments are special:
4626
4628
4627 ``BODYFILE``
4629 ``BODYFILE``
4628 The content of the file defined as the value to this argument will be
4630 The content of the file defined as the value to this argument will be
4629 transferred verbatim as the HTTP request body.
4631 transferred verbatim as the HTTP request body.
4630
4632
4631 ``frame <type> <flags> <payload>``
4633 ``frame <type> <flags> <payload>``
4632 Send a unified protocol frame as part of the request body.
4634 Send a unified protocol frame as part of the request body.
4633
4635
4634 All frames will be collected and sent as the body to the HTTP
4636 All frames will be collected and sent as the body to the HTTP
4635 request.
4637 request.
4636
4638
4637 close
4639 close
4638 -----
4640 -----
4639
4641
4640 Close the connection to the server.
4642 Close the connection to the server.
4641
4643
4642 flush
4644 flush
4643 -----
4645 -----
4644
4646
4645 Flush data written to the server.
4647 Flush data written to the server.
4646
4648
4647 readavailable
4649 readavailable
4648 -------------
4650 -------------
4649
4651
4650 Close the write end of the connection and read all available data from
4652 Close the write end of the connection and read all available data from
4651 the server.
4653 the server.
4652
4654
4653 If the connection to the server encompasses multiple pipes, we poll both
4655 If the connection to the server encompasses multiple pipes, we poll both
4654 pipes and read available data.
4656 pipes and read available data.
4655
4657
4656 readline
4658 readline
4657 --------
4659 --------
4658
4660
4659 Read a line of output from the server. If there are multiple output
4661 Read a line of output from the server. If there are multiple output
4660 pipes, reads only the main pipe.
4662 pipes, reads only the main pipe.
4661
4663
4662 ereadline
4664 ereadline
4663 ---------
4665 ---------
4664
4666
4665 Like ``readline``, but read from the stderr pipe, if available.
4667 Like ``readline``, but read from the stderr pipe, if available.
4666
4668
4667 read <X>
4669 read <X>
4668 --------
4670 --------
4669
4671
4670 ``read()`` N bytes from the server's main output pipe.
4672 ``read()`` N bytes from the server's main output pipe.
4671
4673
4672 eread <X>
4674 eread <X>
4673 ---------
4675 ---------
4674
4676
4675 ``read()`` N bytes from the server's stderr pipe, if available.
4677 ``read()`` N bytes from the server's stderr pipe, if available.
4676
4678
4677 Specifying Unified Frame-Based Protocol Frames
4679 Specifying Unified Frame-Based Protocol Frames
4678 ----------------------------------------------
4680 ----------------------------------------------
4679
4681
4680 It is possible to emit a *Unified Frame-Based Protocol* by using special
4682 It is possible to emit a *Unified Frame-Based Protocol* by using special
4681 syntax.
4683 syntax.
4682
4684
4683 A frame is composed as a type, flags, and payload. These can be parsed
4685 A frame is composed as a type, flags, and payload. These can be parsed
4684 from a string of the form:
4686 from a string of the form:
4685
4687
4686 <request-id> <stream-id> <stream-flags> <type> <flags> <payload>
4688 <request-id> <stream-id> <stream-flags> <type> <flags> <payload>
4687
4689
4688 ``request-id`` and ``stream-id`` are integers defining the request and
4690 ``request-id`` and ``stream-id`` are integers defining the request and
4689 stream identifiers.
4691 stream identifiers.
4690
4692
4691 ``type`` can be an integer value for the frame type or the string name
4693 ``type`` can be an integer value for the frame type or the string name
4692 of the type. The strings are defined in ``wireprotoframing.py``. e.g.
4694 of the type. The strings are defined in ``wireprotoframing.py``. e.g.
4693 ``command-name``.
4695 ``command-name``.
4694
4696
4695 ``stream-flags`` and ``flags`` are a ``|`` delimited list of flag
4697 ``stream-flags`` and ``flags`` are a ``|`` delimited list of flag
4696 components. Each component (and there can be just one) can be an integer
4698 components. Each component (and there can be just one) can be an integer
4697 or a flag name for stream flags or frame flags, respectively. Values are
4699 or a flag name for stream flags or frame flags, respectively. Values are
4698 resolved to integers and then bitwise OR'd together.
4700 resolved to integers and then bitwise OR'd together.
4699
4701
4700 ``payload`` represents the raw frame payload. If it begins with
4702 ``payload`` represents the raw frame payload. If it begins with
4701 ``cbor:``, the following string is evaluated as Python code and the
4703 ``cbor:``, the following string is evaluated as Python code and the
4702 resulting object is fed into a CBOR encoder. Otherwise it is interpreted
4704 resulting object is fed into a CBOR encoder. Otherwise it is interpreted
4703 as a Python byte string literal.
4705 as a Python byte string literal.
4704 """
4706 """
4705 opts = pycompat.byteskwargs(opts)
4707 opts = pycompat.byteskwargs(opts)
4706
4708
4707 if opts[b'localssh'] and not repo:
4709 if opts[b'localssh'] and not repo:
4708 raise error.Abort(_(b'--localssh requires a repository'))
4710 raise error.Abort(_(b'--localssh requires a repository'))
4709
4711
4710 if opts[b'peer'] and opts[b'peer'] not in (
4712 if opts[b'peer'] and opts[b'peer'] not in (
4711 b'raw',
4713 b'raw',
4712 b'ssh1',
4714 b'ssh1',
4713 ):
4715 ):
4714 raise error.Abort(
4716 raise error.Abort(
4715 _(b'invalid value for --peer'),
4717 _(b'invalid value for --peer'),
4716 hint=_(b'valid values are "raw" and "ssh1"'),
4718 hint=_(b'valid values are "raw" and "ssh1"'),
4717 )
4719 )
4718
4720
4719 if path and opts[b'localssh']:
4721 if path and opts[b'localssh']:
4720 raise error.Abort(_(b'cannot specify --localssh with an explicit path'))
4722 raise error.Abort(_(b'cannot specify --localssh with an explicit path'))
4721
4723
4722 if ui.interactive():
4724 if ui.interactive():
4723 ui.write(_(b'(waiting for commands on stdin)\n'))
4725 ui.write(_(b'(waiting for commands on stdin)\n'))
4724
4726
4725 blocks = list(_parsewirelangblocks(ui.fin))
4727 blocks = list(_parsewirelangblocks(ui.fin))
4726
4728
4727 proc = None
4729 proc = None
4728 stdin = None
4730 stdin = None
4729 stdout = None
4731 stdout = None
4730 stderr = None
4732 stderr = None
4731 opener = None
4733 opener = None
4732
4734
4733 if opts[b'localssh']:
4735 if opts[b'localssh']:
4734 # We start the SSH server in its own process so there is process
4736 # We start the SSH server in its own process so there is process
4735 # separation. This prevents a whole class of potential bugs around
4737 # separation. This prevents a whole class of potential bugs around
4736 # shared state from interfering with server operation.
4738 # shared state from interfering with server operation.
4737 args = procutil.hgcmd() + [
4739 args = procutil.hgcmd() + [
4738 b'-R',
4740 b'-R',
4739 repo.root,
4741 repo.root,
4740 b'debugserve',
4742 b'debugserve',
4741 b'--sshstdio',
4743 b'--sshstdio',
4742 ]
4744 ]
4743 proc = subprocess.Popen(
4745 proc = subprocess.Popen(
4744 pycompat.rapply(procutil.tonativestr, args),
4746 pycompat.rapply(procutil.tonativestr, args),
4745 stdin=subprocess.PIPE,
4747 stdin=subprocess.PIPE,
4746 stdout=subprocess.PIPE,
4748 stdout=subprocess.PIPE,
4747 stderr=subprocess.PIPE,
4749 stderr=subprocess.PIPE,
4748 bufsize=0,
4750 bufsize=0,
4749 )
4751 )
4750
4752
4751 stdin = proc.stdin
4753 stdin = proc.stdin
4752 stdout = proc.stdout
4754 stdout = proc.stdout
4753 stderr = proc.stderr
4755 stderr = proc.stderr
4754
4756
4755 # We turn the pipes into observers so we can log I/O.
4757 # We turn the pipes into observers so we can log I/O.
4756 if ui.verbose or opts[b'peer'] == b'raw':
4758 if ui.verbose or opts[b'peer'] == b'raw':
4757 stdin = util.makeloggingfileobject(
4759 stdin = util.makeloggingfileobject(
4758 ui, proc.stdin, b'i', logdata=True
4760 ui, proc.stdin, b'i', logdata=True
4759 )
4761 )
4760 stdout = util.makeloggingfileobject(
4762 stdout = util.makeloggingfileobject(
4761 ui, proc.stdout, b'o', logdata=True
4763 ui, proc.stdout, b'o', logdata=True
4762 )
4764 )
4763 stderr = util.makeloggingfileobject(
4765 stderr = util.makeloggingfileobject(
4764 ui, proc.stderr, b'e', logdata=True
4766 ui, proc.stderr, b'e', logdata=True
4765 )
4767 )
4766
4768
4767 # --localssh also implies the peer connection settings.
4769 # --localssh also implies the peer connection settings.
4768
4770
4769 url = b'ssh://localserver'
4771 url = b'ssh://localserver'
4770 autoreadstderr = not opts[b'noreadstderr']
4772 autoreadstderr = not opts[b'noreadstderr']
4771
4773
4772 if opts[b'peer'] == b'ssh1':
4774 if opts[b'peer'] == b'ssh1':
4773 ui.write(_(b'creating ssh peer for wire protocol version 1\n'))
4775 ui.write(_(b'creating ssh peer for wire protocol version 1\n'))
4774 peer = sshpeer.sshv1peer(
4776 peer = sshpeer.sshv1peer(
4775 ui,
4777 ui,
4776 url,
4778 url,
4777 proc,
4779 proc,
4778 stdin,
4780 stdin,
4779 stdout,
4781 stdout,
4780 stderr,
4782 stderr,
4781 None,
4783 None,
4782 autoreadstderr=autoreadstderr,
4784 autoreadstderr=autoreadstderr,
4783 )
4785 )
4784 elif opts[b'peer'] == b'raw':
4786 elif opts[b'peer'] == b'raw':
4785 ui.write(_(b'using raw connection to peer\n'))
4787 ui.write(_(b'using raw connection to peer\n'))
4786 peer = None
4788 peer = None
4787 else:
4789 else:
4788 ui.write(_(b'creating ssh peer from handshake results\n'))
4790 ui.write(_(b'creating ssh peer from handshake results\n'))
4789 peer = sshpeer.makepeer(
4791 peer = sshpeer.makepeer(
4790 ui,
4792 ui,
4791 url,
4793 url,
4792 proc,
4794 proc,
4793 stdin,
4795 stdin,
4794 stdout,
4796 stdout,
4795 stderr,
4797 stderr,
4796 autoreadstderr=autoreadstderr,
4798 autoreadstderr=autoreadstderr,
4797 )
4799 )
4798
4800
4799 elif path:
4801 elif path:
4800 # We bypass hg.peer() so we can proxy the sockets.
4802 # We bypass hg.peer() so we can proxy the sockets.
4801 # TODO consider not doing this because we skip
4803 # TODO consider not doing this because we skip
4802 # ``hg.wirepeersetupfuncs`` and potentially other useful functionality.
4804 # ``hg.wirepeersetupfuncs`` and potentially other useful functionality.
4803 u = urlutil.url(path)
4805 u = urlutil.url(path)
4804 if u.scheme != b'http':
4806 if u.scheme != b'http':
4805 raise error.Abort(_(b'only http:// paths are currently supported'))
4807 raise error.Abort(_(b'only http:// paths are currently supported'))
4806
4808
4807 url, authinfo = u.authinfo()
4809 url, authinfo = u.authinfo()
4808 openerargs = {
4810 openerargs = {
4809 'useragent': b'Mercurial debugwireproto',
4811 'useragent': b'Mercurial debugwireproto',
4810 }
4812 }
4811
4813
4812 # Turn pipes/sockets into observers so we can log I/O.
4814 # Turn pipes/sockets into observers so we can log I/O.
4813 if ui.verbose:
4815 if ui.verbose:
4814 openerargs.update(
4816 openerargs.update(
4815 {
4817 {
4816 'loggingfh': ui,
4818 'loggingfh': ui,
4817 'loggingname': b's',
4819 'loggingname': b's',
4818 'loggingopts': {
4820 'loggingopts': {
4819 'logdata': True,
4821 'logdata': True,
4820 'logdataapis': False,
4822 'logdataapis': False,
4821 },
4823 },
4822 }
4824 }
4823 )
4825 )
4824
4826
4825 if ui.debugflag:
4827 if ui.debugflag:
4826 openerargs['loggingopts']['logdataapis'] = True
4828 openerargs['loggingopts']['logdataapis'] = True
4827
4829
4828 # Don't send default headers when in raw mode. This allows us to
4830 # Don't send default headers when in raw mode. This allows us to
4829 # bypass most of the behavior of our URL handling code so we can
4831 # bypass most of the behavior of our URL handling code so we can
4830 # have near complete control over what's sent on the wire.
4832 # have near complete control over what's sent on the wire.
4831 if opts[b'peer'] == b'raw':
4833 if opts[b'peer'] == b'raw':
4832 openerargs['sendaccept'] = False
4834 openerargs['sendaccept'] = False
4833
4835
4834 opener = urlmod.opener(ui, authinfo, **openerargs)
4836 opener = urlmod.opener(ui, authinfo, **openerargs)
4835
4837
4836 if opts[b'peer'] == b'raw':
4838 if opts[b'peer'] == b'raw':
4837 ui.write(_(b'using raw connection to peer\n'))
4839 ui.write(_(b'using raw connection to peer\n'))
4838 peer = None
4840 peer = None
4839 elif opts[b'peer']:
4841 elif opts[b'peer']:
4840 raise error.Abort(
4842 raise error.Abort(
4841 _(b'--peer %s not supported with HTTP peers') % opts[b'peer']
4843 _(b'--peer %s not supported with HTTP peers') % opts[b'peer']
4842 )
4844 )
4843 else:
4845 else:
4844 peer = httppeer.makepeer(ui, path, opener=opener)
4846 peer = httppeer.makepeer(ui, path, opener=opener)
4845
4847
4846 # We /could/ populate stdin/stdout with sock.makefile()...
4848 # We /could/ populate stdin/stdout with sock.makefile()...
4847 else:
4849 else:
4848 raise error.Abort(_(b'unsupported connection configuration'))
4850 raise error.Abort(_(b'unsupported connection configuration'))
4849
4851
4850 batchedcommands = None
4852 batchedcommands = None
4851
4853
4852 # Now perform actions based on the parsed wire language instructions.
4854 # Now perform actions based on the parsed wire language instructions.
4853 for action, lines in blocks:
4855 for action, lines in blocks:
4854 if action in (b'raw', b'raw+'):
4856 if action in (b'raw', b'raw+'):
4855 if not stdin:
4857 if not stdin:
4856 raise error.Abort(_(b'cannot call raw/raw+ on this peer'))
4858 raise error.Abort(_(b'cannot call raw/raw+ on this peer'))
4857
4859
4858 # Concatenate the data together.
4860 # Concatenate the data together.
4859 data = b''.join(l.lstrip() for l in lines)
4861 data = b''.join(l.lstrip() for l in lines)
4860 data = stringutil.unescapestr(data)
4862 data = stringutil.unescapestr(data)
4861 stdin.write(data)
4863 stdin.write(data)
4862
4864
4863 if action == b'raw+':
4865 if action == b'raw+':
4864 stdin.flush()
4866 stdin.flush()
4865 elif action == b'flush':
4867 elif action == b'flush':
4866 if not stdin:
4868 if not stdin:
4867 raise error.Abort(_(b'cannot call flush on this peer'))
4869 raise error.Abort(_(b'cannot call flush on this peer'))
4868 stdin.flush()
4870 stdin.flush()
4869 elif action.startswith(b'command'):
4871 elif action.startswith(b'command'):
4870 if not peer:
4872 if not peer:
4871 raise error.Abort(
4873 raise error.Abort(
4872 _(
4874 _(
4873 b'cannot send commands unless peer instance '
4875 b'cannot send commands unless peer instance '
4874 b'is available'
4876 b'is available'
4875 )
4877 )
4876 )
4878 )
4877
4879
4878 command = action.split(b' ', 1)[1]
4880 command = action.split(b' ', 1)[1]
4879
4881
4880 args = {}
4882 args = {}
4881 for line in lines:
4883 for line in lines:
4882 # We need to allow empty values.
4884 # We need to allow empty values.
4883 fields = line.lstrip().split(b' ', 1)
4885 fields = line.lstrip().split(b' ', 1)
4884 if len(fields) == 1:
4886 if len(fields) == 1:
4885 key = fields[0]
4887 key = fields[0]
4886 value = b''
4888 value = b''
4887 else:
4889 else:
4888 key, value = fields
4890 key, value = fields
4889
4891
4890 if value.startswith(b'eval:'):
4892 if value.startswith(b'eval:'):
4891 value = stringutil.evalpythonliteral(value[5:])
4893 value = stringutil.evalpythonliteral(value[5:])
4892 else:
4894 else:
4893 value = stringutil.unescapestr(value)
4895 value = stringutil.unescapestr(value)
4894
4896
4895 args[key] = value
4897 args[key] = value
4896
4898
4897 if batchedcommands is not None:
4899 if batchedcommands is not None:
4898 batchedcommands.append((command, args))
4900 batchedcommands.append((command, args))
4899 continue
4901 continue
4900
4902
4901 ui.status(_(b'sending %s command\n') % command)
4903 ui.status(_(b'sending %s command\n') % command)
4902
4904
4903 if b'PUSHFILE' in args:
4905 if b'PUSHFILE' in args:
4904 with open(args[b'PUSHFILE'], 'rb') as fh:
4906 with open(args[b'PUSHFILE'], 'rb') as fh:
4905 del args[b'PUSHFILE']
4907 del args[b'PUSHFILE']
4906 res, output = peer._callpush(
4908 res, output = peer._callpush(
4907 command, fh, **pycompat.strkwargs(args)
4909 command, fh, **pycompat.strkwargs(args)
4908 )
4910 )
4909 ui.status(_(b'result: %s\n') % stringutil.escapestr(res))
4911 ui.status(_(b'result: %s\n') % stringutil.escapestr(res))
4910 ui.status(
4912 ui.status(
4911 _(b'remote output: %s\n') % stringutil.escapestr(output)
4913 _(b'remote output: %s\n') % stringutil.escapestr(output)
4912 )
4914 )
4913 else:
4915 else:
4914 with peer.commandexecutor() as e:
4916 with peer.commandexecutor() as e:
4915 res = e.callcommand(command, args).result()
4917 res = e.callcommand(command, args).result()
4916
4918
4917 ui.status(
4919 ui.status(
4918 _(b'response: %s\n')
4920 _(b'response: %s\n')
4919 % stringutil.pprint(res, bprefix=True, indent=2)
4921 % stringutil.pprint(res, bprefix=True, indent=2)
4920 )
4922 )
4921
4923
4922 elif action == b'batchbegin':
4924 elif action == b'batchbegin':
4923 if batchedcommands is not None:
4925 if batchedcommands is not None:
4924 raise error.Abort(_(b'nested batchbegin not allowed'))
4926 raise error.Abort(_(b'nested batchbegin not allowed'))
4925
4927
4926 batchedcommands = []
4928 batchedcommands = []
4927 elif action == b'batchsubmit':
4929 elif action == b'batchsubmit':
4928 # There is a batching API we could go through. But it would be
4930 # There is a batching API we could go through. But it would be
4929 # difficult to normalize requests into function calls. It is easier
4931 # difficult to normalize requests into function calls. It is easier
4930 # to bypass this layer and normalize to commands + args.
4932 # to bypass this layer and normalize to commands + args.
4931 ui.status(
4933 ui.status(
4932 _(b'sending batch with %d sub-commands\n')
4934 _(b'sending batch with %d sub-commands\n')
4933 % len(batchedcommands)
4935 % len(batchedcommands)
4934 )
4936 )
4935 assert peer is not None
4937 assert peer is not None
4936 for i, chunk in enumerate(peer._submitbatch(batchedcommands)):
4938 for i, chunk in enumerate(peer._submitbatch(batchedcommands)):
4937 ui.status(
4939 ui.status(
4938 _(b'response #%d: %s\n') % (i, stringutil.escapestr(chunk))
4940 _(b'response #%d: %s\n') % (i, stringutil.escapestr(chunk))
4939 )
4941 )
4940
4942
4941 batchedcommands = None
4943 batchedcommands = None
4942
4944
4943 elif action.startswith(b'httprequest '):
4945 elif action.startswith(b'httprequest '):
4944 if not opener:
4946 if not opener:
4945 raise error.Abort(
4947 raise error.Abort(
4946 _(b'cannot use httprequest without an HTTP peer')
4948 _(b'cannot use httprequest without an HTTP peer')
4947 )
4949 )
4948
4950
4949 request = action.split(b' ', 2)
4951 request = action.split(b' ', 2)
4950 if len(request) != 3:
4952 if len(request) != 3:
4951 raise error.Abort(
4953 raise error.Abort(
4952 _(
4954 _(
4953 b'invalid httprequest: expected format is '
4955 b'invalid httprequest: expected format is '
4954 b'"httprequest <method> <path>'
4956 b'"httprequest <method> <path>'
4955 )
4957 )
4956 )
4958 )
4957
4959
4958 method, httppath = request[1:]
4960 method, httppath = request[1:]
4959 headers = {}
4961 headers = {}
4960 body = None
4962 body = None
4961 frames = []
4963 frames = []
4962 for line in lines:
4964 for line in lines:
4963 line = line.lstrip()
4965 line = line.lstrip()
4964 m = re.match(b'^([a-zA-Z0-9_-]+): (.*)$', line)
4966 m = re.match(b'^([a-zA-Z0-9_-]+): (.*)$', line)
4965 if m:
4967 if m:
4966 # Headers need to use native strings.
4968 # Headers need to use native strings.
4967 key = pycompat.strurl(m.group(1))
4969 key = pycompat.strurl(m.group(1))
4968 value = pycompat.strurl(m.group(2))
4970 value = pycompat.strurl(m.group(2))
4969 headers[key] = value
4971 headers[key] = value
4970 continue
4972 continue
4971
4973
4972 if line.startswith(b'BODYFILE '):
4974 if line.startswith(b'BODYFILE '):
4973 with open(line.split(b' ', 1), b'rb') as fh:
4975 with open(line.split(b' ', 1), b'rb') as fh:
4974 body = fh.read()
4976 body = fh.read()
4975 elif line.startswith(b'frame '):
4977 elif line.startswith(b'frame '):
4976 frame = wireprotoframing.makeframefromhumanstring(
4978 frame = wireprotoframing.makeframefromhumanstring(
4977 line[len(b'frame ') :]
4979 line[len(b'frame ') :]
4978 )
4980 )
4979
4981
4980 frames.append(frame)
4982 frames.append(frame)
4981 else:
4983 else:
4982 raise error.Abort(
4984 raise error.Abort(
4983 _(b'unknown argument to httprequest: %s') % line
4985 _(b'unknown argument to httprequest: %s') % line
4984 )
4986 )
4985
4987
4986 url = path + httppath
4988 url = path + httppath
4987
4989
4988 if frames:
4990 if frames:
4989 body = b''.join(bytes(f) for f in frames)
4991 body = b''.join(bytes(f) for f in frames)
4990
4992
4991 req = urlmod.urlreq.request(pycompat.strurl(url), body, headers)
4993 req = urlmod.urlreq.request(pycompat.strurl(url), body, headers)
4992
4994
4993 # urllib.Request insists on using has_data() as a proxy for
4995 # urllib.Request insists on using has_data() as a proxy for
4994 # determining the request method. Override that to use our
4996 # determining the request method. Override that to use our
4995 # explicitly requested method.
4997 # explicitly requested method.
4996 req.get_method = lambda: pycompat.sysstr(method)
4998 req.get_method = lambda: pycompat.sysstr(method)
4997
4999
4998 try:
5000 try:
4999 res = opener.open(req)
5001 res = opener.open(req)
5000 body = res.read()
5002 body = res.read()
5001 except util.urlerr.urlerror as e:
5003 except util.urlerr.urlerror as e:
5002 # read() method must be called, but only exists in Python 2
5004 # read() method must be called, but only exists in Python 2
5003 getattr(e, 'read', lambda: None)()
5005 getattr(e, 'read', lambda: None)()
5004 continue
5006 continue
5005
5007
5006 ct = res.headers.get('Content-Type')
5008 ct = res.headers.get('Content-Type')
5007 if ct == 'application/mercurial-cbor':
5009 if ct == 'application/mercurial-cbor':
5008 ui.write(
5010 ui.write(
5009 _(b'cbor> %s\n')
5011 _(b'cbor> %s\n')
5010 % stringutil.pprint(
5012 % stringutil.pprint(
5011 cborutil.decodeall(body), bprefix=True, indent=2
5013 cborutil.decodeall(body), bprefix=True, indent=2
5012 )
5014 )
5013 )
5015 )
5014
5016
5015 elif action == b'close':
5017 elif action == b'close':
5016 assert peer is not None
5018 assert peer is not None
5017 peer.close()
5019 peer.close()
5018 elif action == b'readavailable':
5020 elif action == b'readavailable':
5019 if not stdout or not stderr:
5021 if not stdout or not stderr:
5020 raise error.Abort(
5022 raise error.Abort(
5021 _(b'readavailable not available on this peer')
5023 _(b'readavailable not available on this peer')
5022 )
5024 )
5023
5025
5024 stdin.close()
5026 stdin.close()
5025 stdout.read()
5027 stdout.read()
5026 stderr.read()
5028 stderr.read()
5027
5029
5028 elif action == b'readline':
5030 elif action == b'readline':
5029 if not stdout:
5031 if not stdout:
5030 raise error.Abort(_(b'readline not available on this peer'))
5032 raise error.Abort(_(b'readline not available on this peer'))
5031 stdout.readline()
5033 stdout.readline()
5032 elif action == b'ereadline':
5034 elif action == b'ereadline':
5033 if not stderr:
5035 if not stderr:
5034 raise error.Abort(_(b'ereadline not available on this peer'))
5036 raise error.Abort(_(b'ereadline not available on this peer'))
5035 stderr.readline()
5037 stderr.readline()
5036 elif action.startswith(b'read '):
5038 elif action.startswith(b'read '):
5037 count = int(action.split(b' ', 1)[1])
5039 count = int(action.split(b' ', 1)[1])
5038 if not stdout:
5040 if not stdout:
5039 raise error.Abort(_(b'read not available on this peer'))
5041 raise error.Abort(_(b'read not available on this peer'))
5040 stdout.read(count)
5042 stdout.read(count)
5041 elif action.startswith(b'eread '):
5043 elif action.startswith(b'eread '):
5042 count = int(action.split(b' ', 1)[1])
5044 count = int(action.split(b' ', 1)[1])
5043 if not stderr:
5045 if not stderr:
5044 raise error.Abort(_(b'eread not available on this peer'))
5046 raise error.Abort(_(b'eread not available on this peer'))
5045 stderr.read(count)
5047 stderr.read(count)
5046 else:
5048 else:
5047 raise error.Abort(_(b'unknown action: %s') % action)
5049 raise error.Abort(_(b'unknown action: %s') % action)
5048
5050
5049 if batchedcommands is not None:
5051 if batchedcommands is not None:
5050 raise error.Abort(_(b'unclosed "batchbegin" request'))
5052 raise error.Abort(_(b'unclosed "batchbegin" request'))
5051
5053
5052 if peer:
5054 if peer:
5053 peer.close()
5055 peer.close()
5054
5056
5055 if proc:
5057 if proc:
5056 proc.kill()
5058 proc.kill()
General Comments 0
You need to be logged in to leave comments. Login now