Show More
@@ -1,420 +1,503 b'' | |||
|
1 | 1 | # exchangev2.py - repository exchange for wire protocol version 2 |
|
2 | 2 | # |
|
3 | 3 | # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> |
|
4 | 4 | # |
|
5 | 5 | # This software may be used and distributed according to the terms of the |
|
6 | 6 | # GNU General Public License version 2 or any later version. |
|
7 | 7 | |
|
8 | 8 | from __future__ import absolute_import |
|
9 | 9 | |
|
10 | 10 | import collections |
|
11 | 11 | import weakref |
|
12 | 12 | |
|
13 | 13 | from .i18n import _ |
|
14 | 14 | from .node import ( |
|
15 | 15 | nullid, |
|
16 | 16 | short, |
|
17 | 17 | ) |
|
18 | 18 | from . import ( |
|
19 | 19 | bookmarks, |
|
20 | 20 | error, |
|
21 | 21 | mdiff, |
|
22 | 22 | phases, |
|
23 | 23 | pycompat, |
|
24 | 24 | setdiscovery, |
|
25 | 25 | ) |
|
26 | 26 | |
|
27 | 27 | def pull(pullop): |
|
28 | 28 | """Pull using wire protocol version 2.""" |
|
29 | 29 | repo = pullop.repo |
|
30 | 30 | remote = pullop.remote |
|
31 | 31 | tr = pullop.trmanager.transaction() |
|
32 | 32 | |
|
33 | 33 | # Figure out what needs to be fetched. |
|
34 | 34 | common, fetch, remoteheads = _pullchangesetdiscovery( |
|
35 | 35 | repo, remote, pullop.heads, abortwhenunrelated=pullop.force) |
|
36 | 36 | |
|
37 | 37 | # And fetch the data. |
|
38 | 38 | pullheads = pullop.heads or remoteheads |
|
39 | 39 | csetres = _fetchchangesets(repo, tr, remote, common, fetch, pullheads) |
|
40 | 40 | |
|
41 | 41 | # New revisions are written to the changelog. But all other updates |
|
42 | 42 | # are deferred. Do those now. |
|
43 | 43 | |
|
44 | 44 | # Ensure all new changesets are draft by default. If the repo is |
|
45 | 45 | # publishing, the phase will be adjusted by the loop below. |
|
46 | 46 | if csetres['added']: |
|
47 | 47 | phases.registernew(repo, tr, phases.draft, csetres['added']) |
|
48 | 48 | |
|
49 | 49 | # And adjust the phase of all changesets accordingly. |
|
50 | 50 | for phase in phases.phasenames: |
|
51 | 51 | if phase == b'secret' or not csetres['nodesbyphase'][phase]: |
|
52 | 52 | continue |
|
53 | 53 | |
|
54 | 54 | phases.advanceboundary(repo, tr, phases.phasenames.index(phase), |
|
55 | 55 | csetres['nodesbyphase'][phase]) |
|
56 | 56 | |
|
57 | 57 | # Write bookmark updates. |
|
58 | 58 | bookmarks.updatefromremote(repo.ui, repo, csetres['bookmarks'], |
|
59 | 59 | remote.url(), pullop.gettransaction, |
|
60 | 60 | explicit=pullop.explicitbookmarks) |
|
61 | 61 | |
|
62 | 62 | manres = _fetchmanifests(repo, tr, remote, csetres['manifestnodes']) |
|
63 | 63 | |
|
64 | 64 | # Find all file nodes referenced by added manifests and fetch those |
|
65 | 65 | # revisions. |
|
66 | 66 | fnodes = _derivefilesfrommanifests(repo, manres['added']) |
|
67 |
_fetchfiles(repo, tr, remote, fnodes, |
|
|
67 | _fetchfilesfromcsets(repo, tr, remote, fnodes, csetres['added'], | |
|
68 | manres['linkrevs']) | |
|
68 | 69 | |
|
69 | 70 | def _pullchangesetdiscovery(repo, remote, heads, abortwhenunrelated=True): |
|
70 | 71 | """Determine which changesets need to be pulled.""" |
|
71 | 72 | |
|
72 | 73 | if heads: |
|
73 | 74 | knownnode = repo.changelog.hasnode |
|
74 | 75 | if all(knownnode(head) for head in heads): |
|
75 | 76 | return heads, False, heads |
|
76 | 77 | |
|
77 | 78 | # TODO wire protocol version 2 is capable of more efficient discovery |
|
78 | 79 | # than setdiscovery. Consider implementing something better. |
|
79 | 80 | common, fetch, remoteheads = setdiscovery.findcommonheads( |
|
80 | 81 | repo.ui, repo, remote, abortwhenunrelated=abortwhenunrelated) |
|
81 | 82 | |
|
82 | 83 | common = set(common) |
|
83 | 84 | remoteheads = set(remoteheads) |
|
84 | 85 | |
|
85 | 86 | # If a remote head is filtered locally, put it back in the common set. |
|
86 | 87 | # See the comment in exchange._pulldiscoverychangegroup() for more. |
|
87 | 88 | |
|
88 | 89 | if fetch and remoteheads: |
|
89 | 90 | nodemap = repo.unfiltered().changelog.nodemap |
|
90 | 91 | |
|
91 | 92 | common |= {head for head in remoteheads if head in nodemap} |
|
92 | 93 | |
|
93 | 94 | if set(remoteheads).issubset(common): |
|
94 | 95 | fetch = [] |
|
95 | 96 | |
|
96 | 97 | common.discard(nullid) |
|
97 | 98 | |
|
98 | 99 | return common, fetch, remoteheads |
|
99 | 100 | |
|
100 | 101 | def _fetchchangesets(repo, tr, remote, common, fetch, remoteheads): |
|
101 | 102 | # TODO consider adding a step here where we obtain the DAG shape first |
|
102 | 103 | # (or ask the server to slice changesets into chunks for us) so that |
|
103 | 104 | # we can perform multiple fetches in batches. This will facilitate |
|
104 | 105 | # resuming interrupted clones, higher server-side cache hit rates due |
|
105 | 106 | # to smaller segments, etc. |
|
106 | 107 | with remote.commandexecutor() as e: |
|
107 | 108 | objs = e.callcommand(b'changesetdata', { |
|
108 | 109 | b'revisions': [{ |
|
109 | 110 | b'type': b'changesetdagrange', |
|
110 | 111 | b'roots': sorted(common), |
|
111 | 112 | b'heads': sorted(remoteheads), |
|
112 | 113 | }], |
|
113 | 114 | b'fields': {b'bookmarks', b'parents', b'phase', b'revision'}, |
|
114 | 115 | }).result() |
|
115 | 116 | |
|
116 | 117 | # The context manager waits on all response data when exiting. So |
|
117 | 118 | # we need to remain in the context manager in order to stream data. |
|
118 | 119 | return _processchangesetdata(repo, tr, objs) |
|
119 | 120 | |
|
120 | 121 | def _processchangesetdata(repo, tr, objs): |
|
121 | 122 | repo.hook('prechangegroup', throw=True, |
|
122 | 123 | **pycompat.strkwargs(tr.hookargs)) |
|
123 | 124 | |
|
124 | 125 | urepo = repo.unfiltered() |
|
125 | 126 | cl = urepo.changelog |
|
126 | 127 | |
|
127 | 128 | cl.delayupdate(tr) |
|
128 | 129 | |
|
129 | 130 | # The first emitted object is a header describing the data that |
|
130 | 131 | # follows. |
|
131 | 132 | meta = next(objs) |
|
132 | 133 | |
|
133 | 134 | progress = repo.ui.makeprogress(_('changesets'), |
|
134 | 135 | unit=_('chunks'), |
|
135 | 136 | total=meta.get(b'totalitems')) |
|
136 | 137 | |
|
137 | 138 | manifestnodes = {} |
|
138 | 139 | |
|
139 | 140 | def linkrev(node): |
|
140 | 141 | repo.ui.debug('add changeset %s\n' % short(node)) |
|
141 | 142 | # Linkrev for changelog is always self. |
|
142 | 143 | return len(cl) |
|
143 | 144 | |
|
144 | 145 | def onchangeset(cl, node): |
|
145 | 146 | progress.increment() |
|
146 | 147 | |
|
147 | 148 | revision = cl.changelogrevision(node) |
|
148 | 149 | |
|
149 | 150 | # We need to preserve the mapping of changelog revision to node |
|
150 | 151 | # so we can set the linkrev accordingly when manifests are added. |
|
151 | 152 | manifestnodes[cl.rev(node)] = revision.manifest |
|
152 | 153 | |
|
153 | 154 | nodesbyphase = {phase: set() for phase in phases.phasenames} |
|
154 | 155 | remotebookmarks = {} |
|
155 | 156 | |
|
156 | 157 | # addgroup() expects a 7-tuple describing revisions. This normalizes |
|
157 | 158 | # the wire data to that format. |
|
158 | 159 | # |
|
159 | 160 | # This loop also aggregates non-revision metadata, such as phase |
|
160 | 161 | # data. |
|
161 | 162 | def iterrevisions(): |
|
162 | 163 | for cset in objs: |
|
163 | 164 | node = cset[b'node'] |
|
164 | 165 | |
|
165 | 166 | if b'phase' in cset: |
|
166 | 167 | nodesbyphase[cset[b'phase']].add(node) |
|
167 | 168 | |
|
168 | 169 | for mark in cset.get(b'bookmarks', []): |
|
169 | 170 | remotebookmarks[mark] = node |
|
170 | 171 | |
|
171 | 172 | # TODO add mechanism for extensions to examine records so they |
|
172 | 173 | # can siphon off custom data fields. |
|
173 | 174 | |
|
174 | 175 | extrafields = {} |
|
175 | 176 | |
|
176 | 177 | for field, size in cset.get(b'fieldsfollowing', []): |
|
177 | 178 | extrafields[field] = next(objs) |
|
178 | 179 | |
|
179 | 180 | # Some entries might only be metadata only updates. |
|
180 | 181 | if b'revision' not in extrafields: |
|
181 | 182 | continue |
|
182 | 183 | |
|
183 | 184 | data = extrafields[b'revision'] |
|
184 | 185 | |
|
185 | 186 | yield ( |
|
186 | 187 | node, |
|
187 | 188 | cset[b'parents'][0], |
|
188 | 189 | cset[b'parents'][1], |
|
189 | 190 | # Linknode is always itself for changesets. |
|
190 | 191 | cset[b'node'], |
|
191 | 192 | # We always send full revisions. So delta base is not set. |
|
192 | 193 | nullid, |
|
193 | 194 | mdiff.trivialdiffheader(len(data)) + data, |
|
194 | 195 | # Flags not yet supported. |
|
195 | 196 | 0, |
|
196 | 197 | ) |
|
197 | 198 | |
|
198 | 199 | added = cl.addgroup(iterrevisions(), linkrev, weakref.proxy(tr), |
|
199 | 200 | addrevisioncb=onchangeset) |
|
200 | 201 | |
|
201 | 202 | progress.complete() |
|
202 | 203 | |
|
203 | 204 | return { |
|
204 | 205 | 'added': added, |
|
205 | 206 | 'nodesbyphase': nodesbyphase, |
|
206 | 207 | 'bookmarks': remotebookmarks, |
|
207 | 208 | 'manifestnodes': manifestnodes, |
|
208 | 209 | } |
|
209 | 210 | |
|
210 | 211 | def _fetchmanifests(repo, tr, remote, manifestnodes): |
|
211 | 212 | rootmanifest = repo.manifestlog.getstorage(b'') |
|
212 | 213 | |
|
213 | 214 | # Some manifests can be shared between changesets. Filter out revisions |
|
214 | 215 | # we already know about. |
|
215 | 216 | fetchnodes = [] |
|
216 | 217 | linkrevs = {} |
|
217 | 218 | seen = set() |
|
218 | 219 | |
|
219 | 220 | for clrev, node in sorted(manifestnodes.iteritems()): |
|
220 | 221 | if node in seen: |
|
221 | 222 | continue |
|
222 | 223 | |
|
223 | 224 | try: |
|
224 | 225 | rootmanifest.rev(node) |
|
225 | 226 | except error.LookupError: |
|
226 | 227 | fetchnodes.append(node) |
|
227 | 228 | linkrevs[node] = clrev |
|
228 | 229 | |
|
229 | 230 | seen.add(node) |
|
230 | 231 | |
|
231 | 232 | # TODO handle tree manifests |
|
232 | 233 | |
|
233 | 234 | # addgroup() expects 7-tuple describing revisions. This normalizes |
|
234 | 235 | # the wire data to that format. |
|
235 | 236 | def iterrevisions(objs, progress): |
|
236 | 237 | for manifest in objs: |
|
237 | 238 | node = manifest[b'node'] |
|
238 | 239 | |
|
239 | 240 | extrafields = {} |
|
240 | 241 | |
|
241 | 242 | for field, size in manifest.get(b'fieldsfollowing', []): |
|
242 | 243 | extrafields[field] = next(objs) |
|
243 | 244 | |
|
244 | 245 | if b'delta' in extrafields: |
|
245 | 246 | basenode = manifest[b'deltabasenode'] |
|
246 | 247 | delta = extrafields[b'delta'] |
|
247 | 248 | elif b'revision' in extrafields: |
|
248 | 249 | basenode = nullid |
|
249 | 250 | revision = extrafields[b'revision'] |
|
250 | 251 | delta = mdiff.trivialdiffheader(len(revision)) + revision |
|
251 | 252 | else: |
|
252 | 253 | continue |
|
253 | 254 | |
|
254 | 255 | yield ( |
|
255 | 256 | node, |
|
256 | 257 | manifest[b'parents'][0], |
|
257 | 258 | manifest[b'parents'][1], |
|
258 | 259 | # The value passed in is passed to the lookup function passed |
|
259 | 260 | # to addgroup(). We already have a map of manifest node to |
|
260 | 261 | # changelog revision number. So we just pass in the |
|
261 | 262 | # manifest node here and use linkrevs.__getitem__ as the |
|
262 | 263 | # resolution function. |
|
263 | 264 | node, |
|
264 | 265 | basenode, |
|
265 | 266 | delta, |
|
266 | 267 | # Flags not yet supported. |
|
267 | 268 | 0 |
|
268 | 269 | ) |
|
269 | 270 | |
|
270 | 271 | progress.increment() |
|
271 | 272 | |
|
272 | 273 | progress = repo.ui.makeprogress(_('manifests'), unit=_('chunks'), |
|
273 | 274 | total=len(fetchnodes)) |
|
274 | 275 | |
|
275 | 276 | commandmeta = remote.apidescriptor[b'commands'][b'manifestdata'] |
|
276 | 277 | batchsize = commandmeta.get(b'recommendedbatchsize', 10000) |
|
277 | 278 | # TODO make size configurable on client? |
|
278 | 279 | |
|
279 | 280 | # We send commands 1 at a time to the remote. This is not the most |
|
280 | 281 | # efficient because we incur a round trip at the end of each batch. |
|
281 | 282 | # However, the existing frame-based reactor keeps consuming server |
|
282 | 283 | # data in the background. And this results in response data buffering |
|
283 | 284 | # in memory. This can consume gigabytes of memory. |
|
284 | 285 | # TODO send multiple commands in a request once background buffering |
|
285 | 286 | # issues are resolved. |
|
286 | 287 | |
|
287 | 288 | added = [] |
|
288 | 289 | |
|
289 | 290 | for i in pycompat.xrange(0, len(fetchnodes), batchsize): |
|
290 | 291 | batch = [node for node in fetchnodes[i:i + batchsize]] |
|
291 | 292 | if not batch: |
|
292 | 293 | continue |
|
293 | 294 | |
|
294 | 295 | with remote.commandexecutor() as e: |
|
295 | 296 | objs = e.callcommand(b'manifestdata', { |
|
296 | 297 | b'tree': b'', |
|
297 | 298 | b'nodes': batch, |
|
298 | 299 | b'fields': {b'parents', b'revision'}, |
|
299 | 300 | b'haveparents': True, |
|
300 | 301 | }).result() |
|
301 | 302 | |
|
302 | 303 | # Chomp off header object. |
|
303 | 304 | next(objs) |
|
304 | 305 | |
|
305 | 306 | added.extend(rootmanifest.addgroup( |
|
306 | 307 | iterrevisions(objs, progress), |
|
307 | 308 | linkrevs.__getitem__, |
|
308 | 309 | weakref.proxy(tr))) |
|
309 | 310 | |
|
310 | 311 | progress.complete() |
|
311 | 312 | |
|
312 | 313 | return { |
|
313 | 314 | 'added': added, |
|
314 | 315 | 'linkrevs': linkrevs, |
|
315 | 316 | } |
|
316 | 317 | |
|
317 | 318 | def _derivefilesfrommanifests(repo, manifestnodes): |
|
318 | 319 | """Determine what file nodes are relevant given a set of manifest nodes. |
|
319 | 320 | |
|
320 | 321 | Returns a dict mapping file paths to dicts of file node to first manifest |
|
321 | 322 | node. |
|
322 | 323 | """ |
|
323 | 324 | ml = repo.manifestlog |
|
324 | 325 | fnodes = collections.defaultdict(dict) |
|
325 | 326 | |
|
326 | 327 | progress = repo.ui.makeprogress( |
|
327 | 328 | _('scanning manifests'), total=len(manifestnodes)) |
|
328 | 329 | |
|
329 | 330 | with progress: |
|
330 | 331 | for manifestnode in manifestnodes: |
|
331 | 332 | m = ml.get(b'', manifestnode) |
|
332 | 333 | |
|
333 | 334 | # TODO this will pull in unwanted nodes because it takes the storage |
|
334 | 335 | # delta into consideration. What we really want is something that |
|
335 | 336 | # takes the delta between the manifest's parents. And ideally we |
|
336 | 337 | # would ignore file nodes that are known locally. For now, ignore |
|
337 | 338 | # both these limitations. This will result in incremental fetches |
|
338 | 339 | # requesting data we already have. So this is far from ideal. |
|
339 | 340 | md = m.readfast() |
|
340 | 341 | |
|
341 | 342 | for path, fnode in md.items(): |
|
342 | 343 | fnodes[path].setdefault(fnode, manifestnode) |
|
343 | 344 | |
|
344 | 345 | progress.increment() |
|
345 | 346 | |
|
346 | 347 | return fnodes |
|
347 | 348 | |
|
348 | 349 | def _fetchfiles(repo, tr, remote, fnodes, linkrevs): |
|
350 | """Fetch file data from explicit file revisions.""" | |
|
349 | 351 | def iterrevisions(objs, progress): |
|
350 | 352 | for filerevision in objs: |
|
351 | 353 | node = filerevision[b'node'] |
|
352 | 354 | |
|
353 | 355 | extrafields = {} |
|
354 | 356 | |
|
355 | 357 | for field, size in filerevision.get(b'fieldsfollowing', []): |
|
356 | 358 | extrafields[field] = next(objs) |
|
357 | 359 | |
|
358 | 360 | if b'delta' in extrafields: |
|
359 | 361 | basenode = filerevision[b'deltabasenode'] |
|
360 | 362 | delta = extrafields[b'delta'] |
|
361 | 363 | elif b'revision' in extrafields: |
|
362 | 364 | basenode = nullid |
|
363 | 365 | revision = extrafields[b'revision'] |
|
364 | 366 | delta = mdiff.trivialdiffheader(len(revision)) + revision |
|
365 | 367 | else: |
|
366 | 368 | continue |
|
367 | 369 | |
|
368 | 370 | yield ( |
|
369 | 371 | node, |
|
370 | 372 | filerevision[b'parents'][0], |
|
371 | 373 | filerevision[b'parents'][1], |
|
372 | 374 | node, |
|
373 | 375 | basenode, |
|
374 | 376 | delta, |
|
375 | 377 | # Flags not yet supported. |
|
376 | 378 | 0, |
|
377 | 379 | ) |
|
378 | 380 | |
|
379 | 381 | progress.increment() |
|
380 | 382 | |
|
381 | 383 | progress = repo.ui.makeprogress( |
|
382 | 384 | _('files'), unit=_('chunks'), |
|
383 | 385 | total=sum(len(v) for v in fnodes.itervalues())) |
|
384 | 386 | |
|
385 | 387 | # TODO make batch size configurable |
|
386 | 388 | batchsize = 10000 |
|
387 | 389 | fnodeslist = [x for x in sorted(fnodes.items())] |
|
388 | 390 | |
|
389 | 391 | for i in pycompat.xrange(0, len(fnodeslist), batchsize): |
|
390 | 392 | batch = [x for x in fnodeslist[i:i + batchsize]] |
|
391 | 393 | if not batch: |
|
392 | 394 | continue |
|
393 | 395 | |
|
394 | 396 | with remote.commandexecutor() as e: |
|
395 | 397 | fs = [] |
|
396 | 398 | locallinkrevs = {} |
|
397 | 399 | |
|
398 | 400 | for path, nodes in batch: |
|
399 | 401 | fs.append((path, e.callcommand(b'filedata', { |
|
400 | 402 | b'path': path, |
|
401 | 403 | b'nodes': sorted(nodes), |
|
402 | 404 | b'fields': {b'parents', b'revision'}, |
|
403 | 405 | b'haveparents': True, |
|
404 | 406 | }))) |
|
405 | 407 | |
|
406 | 408 | locallinkrevs[path] = { |
|
407 | 409 | node: linkrevs[manifestnode] |
|
408 | 410 | for node, manifestnode in nodes.iteritems()} |
|
409 | 411 | |
|
410 | 412 | for path, f in fs: |
|
411 | 413 | objs = f.result() |
|
412 | 414 | |
|
413 | 415 | # Chomp off header objects. |
|
414 | 416 | next(objs) |
|
415 | 417 | |
|
416 | 418 | store = repo.file(path) |
|
417 | 419 | store.addgroup( |
|
418 | 420 | iterrevisions(objs, progress), |
|
419 | 421 | locallinkrevs[path].__getitem__, |
|
420 | 422 | weakref.proxy(tr)) |
|
423 | ||
|
424 | def _fetchfilesfromcsets(repo, tr, remote, fnodes, csets, manlinkrevs): | |
|
425 | """Fetch file data from explicit changeset revisions.""" | |
|
426 | ||
|
427 | def iterrevisions(objs, remaining, progress): | |
|
428 | while remaining: | |
|
429 | filerevision = next(objs) | |
|
430 | ||
|
431 | node = filerevision[b'node'] | |
|
432 | ||
|
433 | extrafields = {} | |
|
434 | ||
|
435 | for field, size in filerevision.get(b'fieldsfollowing', []): | |
|
436 | extrafields[field] = next(objs) | |
|
437 | ||
|
438 | if b'delta' in extrafields: | |
|
439 | basenode = filerevision[b'deltabasenode'] | |
|
440 | delta = extrafields[b'delta'] | |
|
441 | elif b'revision' in extrafields: | |
|
442 | basenode = nullid | |
|
443 | revision = extrafields[b'revision'] | |
|
444 | delta = mdiff.trivialdiffheader(len(revision)) + revision | |
|
445 | else: | |
|
446 | continue | |
|
447 | ||
|
448 | yield ( | |
|
449 | node, | |
|
450 | filerevision[b'parents'][0], | |
|
451 | filerevision[b'parents'][1], | |
|
452 | node, | |
|
453 | basenode, | |
|
454 | delta, | |
|
455 | # Flags not yet supported. | |
|
456 | 0, | |
|
457 | ) | |
|
458 | ||
|
459 | progress.increment() | |
|
460 | remaining -= 1 | |
|
461 | ||
|
462 | progress = repo.ui.makeprogress( | |
|
463 | _('files'), unit=_('chunks'), | |
|
464 | total=sum(len(v) for v in fnodes.itervalues())) | |
|
465 | ||
|
466 | commandmeta = remote.apidescriptor[b'commands'][b'filesdata'] | |
|
467 | batchsize = commandmeta.get(b'recommendedbatchsize', 50000) | |
|
468 | ||
|
469 | for i in pycompat.xrange(0, len(csets), batchsize): | |
|
470 | batch = [x for x in csets[i:i + batchsize]] | |
|
471 | if not batch: | |
|
472 | continue | |
|
473 | ||
|
474 | with remote.commandexecutor() as e: | |
|
475 | args = { | |
|
476 | b'revisions': [{ | |
|
477 | b'type': b'changesetexplicit', | |
|
478 | b'nodes': batch, | |
|
479 | }], | |
|
480 | b'fields': {b'parents', b'revision'}, | |
|
481 | b'haveparents': True, | |
|
482 | } | |
|
483 | ||
|
484 | objs = e.callcommand(b'filesdata', args).result() | |
|
485 | ||
|
486 | # First object is an overall header. | |
|
487 | overall = next(objs) | |
|
488 | ||
|
489 | # We have overall['totalpaths'] segments. | |
|
490 | for i in pycompat.xrange(overall[b'totalpaths']): | |
|
491 | header = next(objs) | |
|
492 | ||
|
493 | path = header[b'path'] | |
|
494 | store = repo.file(path) | |
|
495 | ||
|
496 | linkrevs = { | |
|
497 | fnode: manlinkrevs[mnode] | |
|
498 | for fnode, mnode in fnodes[path].iteritems()} | |
|
499 | ||
|
500 | store.addgroup(iterrevisions(objs, header[b'totalitems'], | |
|
501 | progress), | |
|
502 | linkrevs.__getitem__, | |
|
503 | weakref.proxy(tr)) |
@@ -1,662 +1,621 b'' | |||
|
1 | 1 | Tests for wire protocol version 2 exchange. |
|
2 | 2 | Tests in this file should be folded into existing tests once protocol |
|
3 | 3 | v2 has enough features that it can be enabled via #testcase in existing |
|
4 | 4 | tests. |
|
5 | 5 | |
|
6 | 6 | $ . $TESTDIR/wireprotohelpers.sh |
|
7 | 7 | $ enablehttpv2client |
|
8 | 8 | |
|
9 | 9 | $ hg init server-simple |
|
10 | 10 | $ enablehttpv2 server-simple |
|
11 | 11 | $ cd server-simple |
|
12 | 12 | $ cat >> .hg/hgrc << EOF |
|
13 | 13 | > [phases] |
|
14 | 14 | > publish = false |
|
15 | 15 | > EOF |
|
16 | 16 | $ echo a0 > a |
|
17 | 17 | $ echo b0 > b |
|
18 | 18 | $ hg -q commit -A -m 'commit 0' |
|
19 | 19 | |
|
20 | 20 | $ echo a1 > a |
|
21 | 21 | $ hg commit -m 'commit 1' |
|
22 | 22 | $ hg phase --public -r . |
|
23 | 23 | $ echo a2 > a |
|
24 | 24 | $ hg commit -m 'commit 2' |
|
25 | 25 | |
|
26 | 26 | $ hg -q up -r 0 |
|
27 | 27 | $ echo b1 > b |
|
28 | 28 | $ hg -q commit -m 'head 2 commit 1' |
|
29 | 29 | $ echo b2 > b |
|
30 | 30 | $ hg -q commit -m 'head 2 commit 2' |
|
31 | 31 | |
|
32 | 32 | $ hg serve -p $HGPORT -d --pid-file hg.pid -E error.log |
|
33 | 33 | $ cat hg.pid > $DAEMON_PIDS |
|
34 | 34 | |
|
35 | 35 | $ cd .. |
|
36 | 36 | |
|
37 | 37 | Test basic clone |
|
38 | 38 | |
|
39 | 39 | $ hg --debug clone -U http://localhost:$HGPORT client-simple |
|
40 | 40 | using http://localhost:$HGPORT/ |
|
41 | 41 | sending capabilities command |
|
42 | 42 | query 1; heads |
|
43 | 43 | sending 2 commands |
|
44 | 44 | sending command heads: {} |
|
45 | 45 | sending command known: { |
|
46 | 46 | 'nodes': [] |
|
47 | 47 | } |
|
48 | 48 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
49 | 49 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
50 | 50 | received frame(size=43; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
51 | 51 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
52 | 52 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
53 | 53 | received frame(size=1; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
54 | 54 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) |
|
55 | 55 | sending 1 commands |
|
56 | 56 | sending command changesetdata: { |
|
57 | 57 | 'fields': set([ |
|
58 | 58 | 'bookmarks', |
|
59 | 59 | 'parents', |
|
60 | 60 | 'phase', |
|
61 | 61 | 'revision' |
|
62 | 62 | ]), |
|
63 | 63 | 'revisions': [ |
|
64 | 64 | { |
|
65 | 65 | 'heads': [ |
|
66 | 66 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1', |
|
67 | 67 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f' |
|
68 | 68 | ], |
|
69 | 69 | 'roots': [], |
|
70 | 70 | 'type': 'changesetdagrange' |
|
71 | 71 | } |
|
72 | 72 | ] |
|
73 | 73 | } |
|
74 | 74 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
75 | 75 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
76 | 76 | received frame(size=941; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
77 | 77 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
78 | 78 | add changeset 3390ef850073 |
|
79 | 79 | add changeset 4432d83626e8 |
|
80 | 80 | add changeset cd2534766bec |
|
81 | 81 | add changeset e96ae20f4188 |
|
82 | 82 | add changeset caa2a465451d |
|
83 | 83 | checking for updated bookmarks |
|
84 | 84 | sending 1 commands |
|
85 | 85 | sending command manifestdata: { |
|
86 | 86 | 'fields': set([ |
|
87 | 87 | 'parents', |
|
88 | 88 | 'revision' |
|
89 | 89 | ]), |
|
90 | 90 | 'haveparents': True, |
|
91 | 91 | 'nodes': [ |
|
92 | 92 | '\x99/Gy\x02\x9a=\xf8\xd0fm\x00\xbb\x92OicN&A', |
|
93 | 93 | '\xa9\x88\xfbCX>\x87\x1d\x1e\xd5u\x0e\xe0t\xc6\xd8@\xbb\xbf\xc8', |
|
94 | 94 | '\xec\x80NH\x8c \x88\xc25\t\x9a\x10 u\x13\xbe\xcd\xc3\xdd\xa5', |
|
95 | 95 | '\x04\\\x7f9\'\xda\x13\xe7Z\xf8\xf0\xe4\xf0HI\xe4a\xa9x\x0f', |
|
96 | 96 | '7\x9c\xb0\xc2\xe6d\\y\xdd\xc5\x9a\x1dG\'\xa9\xfb\x83\n\xeb&' |
|
97 | 97 | ], |
|
98 | 98 | 'tree': '' |
|
99 | 99 | } |
|
100 | 100 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
101 | 101 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
102 | 102 | received frame(size=992; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
103 | 103 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
104 |
sending |
|
|
105 | sending command filedata: { | |
|
104 | sending 1 commands | |
|
105 | sending command filesdata: { | |
|
106 | 106 | 'fields': set([ |
|
107 | 107 | 'parents', |
|
108 | 108 | 'revision' |
|
109 | 109 | ]), |
|
110 | 110 | 'haveparents': True, |
|
111 |
' |
|
|
112 | '+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda', | |
|
113 | '\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc', | |
|
114 | '\xc2\xa2\x05\xc8\xb2\xad\xe2J\xf2`b\xe5<\xd5\xbc8\x01\xd6`\xda' | |
|
115 | ], | |
|
116 | 'path': 'a' | |
|
117 | } | |
|
118 | sending command filedata: { | |
|
119 | 'fields': set([ | |
|
120 | 'parents', | |
|
121 | 'revision' | |
|
122 |
] |
|
|
123 | 'haveparents': True, | |
|
124 | 'nodes': [ | |
|
125 | '\x81\x9e%\x8d1\xa5\xe1`f)\xf3e\xbb\x90*\x1b!\xeeB\x16', | |
|
126 | '\xb1zk\xd3g=\x9a\xb8\xce\xd5\x81\xa2\t\xf6/=\xa5\xccEx', | |
|
127 | '\xc5\xb1\xf9\xd3n\x1c\xc18\xbf\xb6\xef\xb3\xde\xb7]\x8c\xcad\x94\xc3' | |
|
128 | ], | |
|
129 | 'path': 'b' | |
|
111 | 'revisions': [ | |
|
112 | { | |
|
113 | 'nodes': [ | |
|
114 | '3\x90\xef\x85\x00s\xfb\xc2\xf0\xdf\xff"D4,\x8e\x92)\x01:', | |
|
115 | 'D2\xd86&\xe8\xa9\x86U\xf0b\xec\x1f*C\xb0\x7f\x7f\xbb\xb0', | |
|
116 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f', | |
|
117 | '\xe9j\xe2\x0fA\x88H{\x9a\xe4\xef9A\xc2|\x81\x141F\xe5', | |
|
118 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1' | |
|
119 | ], | |
|
120 | 'type': 'changesetexplicit' | |
|
121 | } | |
|
122 | ] | |
|
130 | 123 | } |
|
131 | 124 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
132 | 125 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
133 |
received frame(size= |
|
|
126 | received frame(size=901; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
134 | 127 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
135 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
136 | received frame(size=431; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
137 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) | |
|
138 | 128 | updating the branch cache |
|
139 | 129 | new changesets 3390ef850073:caa2a465451d (3 drafts) |
|
140 | 130 | (sent 5 HTTP requests and * bytes; received * bytes in responses) (glob) |
|
141 | 131 | |
|
142 | 132 | All changesets should have been transferred |
|
143 | 133 | |
|
144 | 134 | $ hg -R client-simple debugindex -c |
|
145 | 135 | rev linkrev nodeid p1 p2 |
|
146 | 136 | 0 0 3390ef850073 000000000000 000000000000 |
|
147 | 137 | 1 1 4432d83626e8 3390ef850073 000000000000 |
|
148 | 138 | 2 2 cd2534766bec 4432d83626e8 000000000000 |
|
149 | 139 | 3 3 e96ae20f4188 3390ef850073 000000000000 |
|
150 | 140 | 4 4 caa2a465451d e96ae20f4188 000000000000 |
|
151 | 141 | |
|
152 | 142 | $ hg -R client-simple log -G -T '{rev} {node} {phase}\n' |
|
153 | 143 | o 4 caa2a465451dd1facda0f5b12312c355584188a1 draft |
|
154 | 144 | | |
|
155 | 145 | o 3 e96ae20f4188487b9ae4ef3941c27c81143146e5 draft |
|
156 | 146 | | |
|
157 | 147 | | o 2 cd2534766bece138c7c1afdc6825302f0f62d81f draft |
|
158 | 148 | | | |
|
159 | 149 | | o 1 4432d83626e8a98655f062ec1f2a43b07f7fbbb0 public |
|
160 | 150 | |/ |
|
161 | 151 | o 0 3390ef850073fbc2f0dfff2244342c8e9229013a public |
|
162 | 152 | |
|
163 | 153 | |
|
164 | 154 | All manifests should have been transferred |
|
165 | 155 | |
|
166 | 156 | $ hg -R client-simple debugindex -m |
|
167 | 157 | rev linkrev nodeid p1 p2 |
|
168 | 158 | 0 0 992f4779029a 000000000000 000000000000 |
|
169 | 159 | 1 1 a988fb43583e 992f4779029a 000000000000 |
|
170 | 160 | 2 2 ec804e488c20 a988fb43583e 000000000000 |
|
171 | 161 | 3 3 045c7f3927da 992f4779029a 000000000000 |
|
172 | 162 | 4 4 379cb0c2e664 045c7f3927da 000000000000 |
|
173 | 163 | |
|
174 | 164 | Cloning only a specific revision works |
|
175 | 165 | |
|
176 | 166 | $ hg --debug clone -U -r 4432d83626e8 http://localhost:$HGPORT client-singlehead |
|
177 | 167 | using http://localhost:$HGPORT/ |
|
178 | 168 | sending capabilities command |
|
179 | 169 | sending 1 commands |
|
180 | 170 | sending command lookup: { |
|
181 | 171 | 'key': '4432d83626e8' |
|
182 | 172 | } |
|
183 | 173 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
184 | 174 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
185 | 175 | received frame(size=21; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
186 | 176 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
187 | 177 | query 1; heads |
|
188 | 178 | sending 2 commands |
|
189 | 179 | sending command heads: {} |
|
190 | 180 | sending command known: { |
|
191 | 181 | 'nodes': [] |
|
192 | 182 | } |
|
193 | 183 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
194 | 184 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
195 | 185 | received frame(size=43; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
196 | 186 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
197 | 187 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
198 | 188 | received frame(size=1; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
199 | 189 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) |
|
200 | 190 | sending 1 commands |
|
201 | 191 | sending command changesetdata: { |
|
202 | 192 | 'fields': set([ |
|
203 | 193 | 'bookmarks', |
|
204 | 194 | 'parents', |
|
205 | 195 | 'phase', |
|
206 | 196 | 'revision' |
|
207 | 197 | ]), |
|
208 | 198 | 'revisions': [ |
|
209 | 199 | { |
|
210 | 200 | 'heads': [ |
|
211 | 201 | 'D2\xd86&\xe8\xa9\x86U\xf0b\xec\x1f*C\xb0\x7f\x7f\xbb\xb0' |
|
212 | 202 | ], |
|
213 | 203 | 'roots': [], |
|
214 | 204 | 'type': 'changesetdagrange' |
|
215 | 205 | } |
|
216 | 206 | ] |
|
217 | 207 | } |
|
218 | 208 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
219 | 209 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
220 | 210 | received frame(size=381; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
221 | 211 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
222 | 212 | add changeset 3390ef850073 |
|
223 | 213 | add changeset 4432d83626e8 |
|
224 | 214 | checking for updated bookmarks |
|
225 | 215 | sending 1 commands |
|
226 | 216 | sending command manifestdata: { |
|
227 | 217 | 'fields': set([ |
|
228 | 218 | 'parents', |
|
229 | 219 | 'revision' |
|
230 | 220 | ]), |
|
231 | 221 | 'haveparents': True, |
|
232 | 222 | 'nodes': [ |
|
233 | 223 | '\x99/Gy\x02\x9a=\xf8\xd0fm\x00\xbb\x92OicN&A', |
|
234 | 224 | '\xa9\x88\xfbCX>\x87\x1d\x1e\xd5u\x0e\xe0t\xc6\xd8@\xbb\xbf\xc8' |
|
235 | 225 | ], |
|
236 | 226 | 'tree': '' |
|
237 | 227 | } |
|
238 | 228 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
239 | 229 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
240 | 230 | received frame(size=404; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
241 | 231 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
242 |
sending |
|
|
243 | sending command filedata: { | |
|
232 | sending 1 commands | |
|
233 | sending command filesdata: { | |
|
244 | 234 | 'fields': set([ |
|
245 | 235 | 'parents', |
|
246 | 236 | 'revision' |
|
247 | 237 | ]), |
|
248 | 238 | 'haveparents': True, |
|
249 |
' |
|
|
250 | '+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda', | |
|
251 | '\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc' | |
|
252 | ], | |
|
253 | 'path': 'a' | |
|
254 | } | |
|
255 | sending command filedata: { | |
|
256 | 'fields': set([ | |
|
257 | 'parents', | |
|
258 | 'revision' | |
|
259 | ]), | |
|
260 | 'haveparents': True, | |
|
261 | 'nodes': [ | |
|
262 | '\x81\x9e%\x8d1\xa5\xe1`f)\xf3e\xbb\x90*\x1b!\xeeB\x16' | |
|
263 | ], | |
|
264 | 'path': 'b' | |
|
239 | 'revisions': [ | |
|
240 | { | |
|
241 | 'nodes': [ | |
|
242 | '3\x90\xef\x85\x00s\xfb\xc2\xf0\xdf\xff"D4,\x8e\x92)\x01:', | |
|
243 | 'D2\xd86&\xe8\xa9\x86U\xf0b\xec\x1f*C\xb0\x7f\x7f\xbb\xb0' | |
|
244 | ], | |
|
245 | 'type': 'changesetexplicit' | |
|
246 | } | |
|
247 | ] | |
|
265 | 248 | } |
|
266 | 249 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
267 | 250 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
268 |
received frame(size= |
|
|
251 | received frame(size=439; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
269 | 252 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
270 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
271 | received frame(size=123; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
272 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) | |
|
273 | 253 | updating the branch cache |
|
274 | 254 | new changesets 3390ef850073:4432d83626e8 |
|
275 | 255 | (sent 6 HTTP requests and * bytes; received * bytes in responses) (glob) |
|
276 | 256 | |
|
277 | 257 | $ cd client-singlehead |
|
278 | 258 | |
|
279 | 259 | $ hg log -G -T '{rev} {node} {phase}\n' |
|
280 | 260 | o 1 4432d83626e8a98655f062ec1f2a43b07f7fbbb0 public |
|
281 | 261 | | |
|
282 | 262 | o 0 3390ef850073fbc2f0dfff2244342c8e9229013a public |
|
283 | 263 | |
|
284 | 264 | |
|
285 | 265 | $ hg debugindex -m |
|
286 | 266 | rev linkrev nodeid p1 p2 |
|
287 | 267 | 0 0 992f4779029a 000000000000 000000000000 |
|
288 | 268 | 1 1 a988fb43583e 992f4779029a 000000000000 |
|
289 | 269 | |
|
290 | 270 | Incremental pull works |
|
291 | 271 | |
|
292 | 272 | $ hg --debug pull |
|
293 | 273 | pulling from http://localhost:$HGPORT/ |
|
294 | 274 | using http://localhost:$HGPORT/ |
|
295 | 275 | sending capabilities command |
|
296 | 276 | query 1; heads |
|
297 | 277 | sending 2 commands |
|
298 | 278 | sending command heads: {} |
|
299 | 279 | sending command known: { |
|
300 | 280 | 'nodes': [ |
|
301 | 281 | 'D2\xd86&\xe8\xa9\x86U\xf0b\xec\x1f*C\xb0\x7f\x7f\xbb\xb0' |
|
302 | 282 | ] |
|
303 | 283 | } |
|
304 | 284 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
305 | 285 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
306 | 286 | received frame(size=43; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
307 | 287 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
308 | 288 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
309 | 289 | received frame(size=2; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
310 | 290 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) |
|
311 | 291 | searching for changes |
|
312 | 292 | all local heads known remotely |
|
313 | 293 | sending 1 commands |
|
314 | 294 | sending command changesetdata: { |
|
315 | 295 | 'fields': set([ |
|
316 | 296 | 'bookmarks', |
|
317 | 297 | 'parents', |
|
318 | 298 | 'phase', |
|
319 | 299 | 'revision' |
|
320 | 300 | ]), |
|
321 | 301 | 'revisions': [ |
|
322 | 302 | { |
|
323 | 303 | 'heads': [ |
|
324 | 304 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1', |
|
325 | 305 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f' |
|
326 | 306 | ], |
|
327 | 307 | 'roots': [ |
|
328 | 308 | 'D2\xd86&\xe8\xa9\x86U\xf0b\xec\x1f*C\xb0\x7f\x7f\xbb\xb0' |
|
329 | 309 | ], |
|
330 | 310 | 'type': 'changesetdagrange' |
|
331 | 311 | } |
|
332 | 312 | ] |
|
333 | 313 | } |
|
334 | 314 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
335 | 315 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
336 | 316 | received frame(size=573; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
337 | 317 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
338 | 318 | add changeset cd2534766bec |
|
339 | 319 | add changeset e96ae20f4188 |
|
340 | 320 | add changeset caa2a465451d |
|
341 | 321 | checking for updated bookmarks |
|
342 | 322 | sending 1 commands |
|
343 | 323 | sending command manifestdata: { |
|
344 | 324 | 'fields': set([ |
|
345 | 325 | 'parents', |
|
346 | 326 | 'revision' |
|
347 | 327 | ]), |
|
348 | 328 | 'haveparents': True, |
|
349 | 329 | 'nodes': [ |
|
350 | 330 | '\xec\x80NH\x8c \x88\xc25\t\x9a\x10 u\x13\xbe\xcd\xc3\xdd\xa5', |
|
351 | 331 | '\x04\\\x7f9\'\xda\x13\xe7Z\xf8\xf0\xe4\xf0HI\xe4a\xa9x\x0f', |
|
352 | 332 | '7\x9c\xb0\xc2\xe6d\\y\xdd\xc5\x9a\x1dG\'\xa9\xfb\x83\n\xeb&' |
|
353 | 333 | ], |
|
354 | 334 | 'tree': '' |
|
355 | 335 | } |
|
356 | 336 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
357 | 337 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
358 | 338 | received frame(size=601; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
359 | 339 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
360 |
sending |
|
|
361 | sending command filedata: { | |
|
340 | sending 1 commands | |
|
341 | sending command filesdata: { | |
|
362 | 342 | 'fields': set([ |
|
363 | 343 | 'parents', |
|
364 | 344 | 'revision' |
|
365 | 345 | ]), |
|
366 | 346 | 'haveparents': True, |
|
367 |
' |
|
|
368 | '+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda', | |
|
369 | '\xc2\xa2\x05\xc8\xb2\xad\xe2J\xf2`b\xe5<\xd5\xbc8\x01\xd6`\xda' | |
|
370 | ], | |
|
371 | 'path': 'a' | |
|
372 | } | |
|
373 | sending command filedata: { | |
|
374 | 'fields': set([ | |
|
375 | 'parents', | |
|
376 | 'revision' | |
|
377 | ]), | |
|
378 | 'haveparents': True, | |
|
379 | 'nodes': [ | |
|
380 | '\x81\x9e%\x8d1\xa5\xe1`f)\xf3e\xbb\x90*\x1b!\xeeB\x16', | |
|
381 | '\xb1zk\xd3g=\x9a\xb8\xce\xd5\x81\xa2\t\xf6/=\xa5\xccEx', | |
|
382 | '\xc5\xb1\xf9\xd3n\x1c\xc18\xbf\xb6\xef\xb3\xde\xb7]\x8c\xcad\x94\xc3' | |
|
383 | ], | |
|
384 | 'path': 'b' | |
|
347 | 'revisions': [ | |
|
348 | { | |
|
349 | 'nodes': [ | |
|
350 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f', | |
|
351 | '\xe9j\xe2\x0fA\x88H{\x9a\xe4\xef9A\xc2|\x81\x141F\xe5', | |
|
352 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1' | |
|
353 | ], | |
|
354 | 'type': 'changesetexplicit' | |
|
355 | } | |
|
356 | ] | |
|
385 | 357 | } |
|
386 | 358 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
387 | 359 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
388 |
received frame(size=27 |
|
|
360 | received frame(size=527; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
389 | 361 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
390 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
391 | received frame(size=431; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
392 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) | |
|
393 | 362 | updating the branch cache |
|
394 | 363 | new changesets cd2534766bec:caa2a465451d (3 drafts) |
|
395 | 364 | (run 'hg update' to get a working copy) |
|
396 | 365 | (sent 5 HTTP requests and * bytes; received * bytes in responses) (glob) |
|
397 | 366 | |
|
398 | 367 | $ hg log -G -T '{rev} {node} {phase}\n' |
|
399 | 368 | o 4 caa2a465451dd1facda0f5b12312c355584188a1 draft |
|
400 | 369 | | |
|
401 | 370 | o 3 e96ae20f4188487b9ae4ef3941c27c81143146e5 draft |
|
402 | 371 | | |
|
403 | 372 | | o 2 cd2534766bece138c7c1afdc6825302f0f62d81f draft |
|
404 | 373 | | | |
|
405 | 374 | | o 1 4432d83626e8a98655f062ec1f2a43b07f7fbbb0 public |
|
406 | 375 | |/ |
|
407 | 376 | o 0 3390ef850073fbc2f0dfff2244342c8e9229013a public |
|
408 | 377 | |
|
409 | 378 | |
|
410 | 379 | $ hg debugindex -m |
|
411 | 380 | rev linkrev nodeid p1 p2 |
|
412 | 381 | 0 0 992f4779029a 000000000000 000000000000 |
|
413 | 382 | 1 1 a988fb43583e 992f4779029a 000000000000 |
|
414 | 383 | 2 2 ec804e488c20 a988fb43583e 000000000000 |
|
415 | 384 | 3 3 045c7f3927da 992f4779029a 000000000000 |
|
416 | 385 | 4 4 379cb0c2e664 045c7f3927da 000000000000 |
|
417 | 386 | |
|
418 | 387 | Phase-only update works |
|
419 | 388 | TODO this doesn't work |
|
420 | 389 | |
|
421 | 390 | $ hg -R ../server-simple phase --public -r caa2a465451dd |
|
422 | 391 | $ hg --debug pull |
|
423 | 392 | pulling from http://localhost:$HGPORT/ |
|
424 | 393 | using http://localhost:$HGPORT/ |
|
425 | 394 | sending capabilities command |
|
426 | 395 | query 1; heads |
|
427 | 396 | sending 2 commands |
|
428 | 397 | sending command heads: {} |
|
429 | 398 | sending command known: { |
|
430 | 399 | 'nodes': [ |
|
431 | 400 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f', |
|
432 | 401 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1' |
|
433 | 402 | ] |
|
434 | 403 | } |
|
435 | 404 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
436 | 405 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
437 | 406 | received frame(size=43; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
438 | 407 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
439 | 408 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
440 | 409 | received frame(size=3; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
441 | 410 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) |
|
442 | 411 | searching for changes |
|
443 | 412 | all remote heads known locally |
|
444 | 413 | sending 1 commands |
|
445 | 414 | sending command changesetdata: { |
|
446 | 415 | 'fields': set([ |
|
447 | 416 | 'bookmarks', |
|
448 | 417 | 'parents', |
|
449 | 418 | 'phase', |
|
450 | 419 | 'revision' |
|
451 | 420 | ]), |
|
452 | 421 | 'revisions': [ |
|
453 | 422 | { |
|
454 | 423 | 'heads': [ |
|
455 | 424 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1', |
|
456 | 425 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f' |
|
457 | 426 | ], |
|
458 | 427 | 'roots': [ |
|
459 | 428 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1', |
|
460 | 429 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f' |
|
461 | 430 | ], |
|
462 | 431 | 'type': 'changesetdagrange' |
|
463 | 432 | } |
|
464 | 433 | ] |
|
465 | 434 | } |
|
466 | 435 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
467 | 436 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
468 | 437 | received frame(size=13; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
469 | 438 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
470 | 439 | checking for updated bookmarks |
|
471 | 440 | (run 'hg update' to get a working copy) |
|
472 | 441 | (sent 3 HTTP requests and * bytes; received * bytes in responses) (glob) |
|
473 | 442 | |
|
474 | 443 | $ hg log -G -T '{rev} {node} {phase}\n' |
|
475 | 444 | o 4 caa2a465451dd1facda0f5b12312c355584188a1 draft |
|
476 | 445 | | |
|
477 | 446 | o 3 e96ae20f4188487b9ae4ef3941c27c81143146e5 draft |
|
478 | 447 | | |
|
479 | 448 | | o 2 cd2534766bece138c7c1afdc6825302f0f62d81f draft |
|
480 | 449 | | | |
|
481 | 450 | | o 1 4432d83626e8a98655f062ec1f2a43b07f7fbbb0 public |
|
482 | 451 | |/ |
|
483 | 452 | o 0 3390ef850073fbc2f0dfff2244342c8e9229013a public |
|
484 | 453 | |
|
485 | 454 | |
|
486 | 455 | $ cd .. |
|
487 | 456 | |
|
488 | 457 | Bookmarks are transferred on clone |
|
489 | 458 | |
|
490 | 459 | $ hg -R server-simple bookmark -r 3390ef850073fbc2f0dfff2244342c8e9229013a book-1 |
|
491 | 460 | $ hg -R server-simple bookmark -r cd2534766bece138c7c1afdc6825302f0f62d81f book-2 |
|
492 | 461 | |
|
493 | 462 | $ hg --debug clone -U http://localhost:$HGPORT/ client-bookmarks |
|
494 | 463 | using http://localhost:$HGPORT/ |
|
495 | 464 | sending capabilities command |
|
496 | 465 | query 1; heads |
|
497 | 466 | sending 2 commands |
|
498 | 467 | sending command heads: {} |
|
499 | 468 | sending command known: { |
|
500 | 469 | 'nodes': [] |
|
501 | 470 | } |
|
502 | 471 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
503 | 472 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
504 | 473 | received frame(size=43; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
505 | 474 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
506 | 475 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
507 | 476 | received frame(size=1; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
508 | 477 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) |
|
509 | 478 | sending 1 commands |
|
510 | 479 | sending command changesetdata: { |
|
511 | 480 | 'fields': set([ |
|
512 | 481 | 'bookmarks', |
|
513 | 482 | 'parents', |
|
514 | 483 | 'phase', |
|
515 | 484 | 'revision' |
|
516 | 485 | ]), |
|
517 | 486 | 'revisions': [ |
|
518 | 487 | { |
|
519 | 488 | 'heads': [ |
|
520 | 489 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1', |
|
521 | 490 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f' |
|
522 | 491 | ], |
|
523 | 492 | 'roots': [], |
|
524 | 493 | 'type': 'changesetdagrange' |
|
525 | 494 | } |
|
526 | 495 | ] |
|
527 | 496 | } |
|
528 | 497 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
529 | 498 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
530 | 499 | received frame(size=979; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
531 | 500 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
532 | 501 | add changeset 3390ef850073 |
|
533 | 502 | add changeset 4432d83626e8 |
|
534 | 503 | add changeset cd2534766bec |
|
535 | 504 | add changeset e96ae20f4188 |
|
536 | 505 | add changeset caa2a465451d |
|
537 | 506 | checking for updated bookmarks |
|
538 | 507 | adding remote bookmark book-1 |
|
539 | 508 | adding remote bookmark book-2 |
|
540 | 509 | sending 1 commands |
|
541 | 510 | sending command manifestdata: { |
|
542 | 511 | 'fields': set([ |
|
543 | 512 | 'parents', |
|
544 | 513 | 'revision' |
|
545 | 514 | ]), |
|
546 | 515 | 'haveparents': True, |
|
547 | 516 | 'nodes': [ |
|
548 | 517 | '\x99/Gy\x02\x9a=\xf8\xd0fm\x00\xbb\x92OicN&A', |
|
549 | 518 | '\xa9\x88\xfbCX>\x87\x1d\x1e\xd5u\x0e\xe0t\xc6\xd8@\xbb\xbf\xc8', |
|
550 | 519 | '\xec\x80NH\x8c \x88\xc25\t\x9a\x10 u\x13\xbe\xcd\xc3\xdd\xa5', |
|
551 | 520 | '\x04\\\x7f9\'\xda\x13\xe7Z\xf8\xf0\xe4\xf0HI\xe4a\xa9x\x0f', |
|
552 | 521 | '7\x9c\xb0\xc2\xe6d\\y\xdd\xc5\x9a\x1dG\'\xa9\xfb\x83\n\xeb&' |
|
553 | 522 | ], |
|
554 | 523 | 'tree': '' |
|
555 | 524 | } |
|
556 | 525 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
557 | 526 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
558 | 527 | received frame(size=992; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
559 | 528 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
560 |
sending |
|
|
561 | sending command filedata: { | |
|
529 | sending 1 commands | |
|
530 | sending command filesdata: { | |
|
562 | 531 | 'fields': set([ |
|
563 | 532 | 'parents', |
|
564 | 533 | 'revision' |
|
565 | 534 | ]), |
|
566 | 535 | 'haveparents': True, |
|
567 |
' |
|
|
568 | '+N\xb0s\x19\xbf\xa0w\xa4\n/\x04\x916Y\xae\xf0\xdaB\xda', | |
|
569 | '\x9a8\x12)\x97\xb3\xac\x97\xbe*\x9a\xa2\xe5V\x83\x83A\xfd\xf2\xcc', | |
|
570 | '\xc2\xa2\x05\xc8\xb2\xad\xe2J\xf2`b\xe5<\xd5\xbc8\x01\xd6`\xda' | |
|
571 | ], | |
|
572 | 'path': 'a' | |
|
573 | } | |
|
574 | sending command filedata: { | |
|
575 | 'fields': set([ | |
|
576 | 'parents', | |
|
577 | 'revision' | |
|
578 |
] |
|
|
579 | 'haveparents': True, | |
|
580 | 'nodes': [ | |
|
581 | '\x81\x9e%\x8d1\xa5\xe1`f)\xf3e\xbb\x90*\x1b!\xeeB\x16', | |
|
582 | '\xb1zk\xd3g=\x9a\xb8\xce\xd5\x81\xa2\t\xf6/=\xa5\xccEx', | |
|
583 | '\xc5\xb1\xf9\xd3n\x1c\xc18\xbf\xb6\xef\xb3\xde\xb7]\x8c\xcad\x94\xc3' | |
|
584 | ], | |
|
585 | 'path': 'b' | |
|
536 | 'revisions': [ | |
|
537 | { | |
|
538 | 'nodes': [ | |
|
539 | '3\x90\xef\x85\x00s\xfb\xc2\xf0\xdf\xff"D4,\x8e\x92)\x01:', | |
|
540 | 'D2\xd86&\xe8\xa9\x86U\xf0b\xec\x1f*C\xb0\x7f\x7f\xbb\xb0', | |
|
541 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f', | |
|
542 | '\xe9j\xe2\x0fA\x88H{\x9a\xe4\xef9A\xc2|\x81\x141F\xe5', | |
|
543 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1' | |
|
544 | ], | |
|
545 | 'type': 'changesetexplicit' | |
|
546 | } | |
|
547 | ] | |
|
586 | 548 | } |
|
587 | 549 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
588 | 550 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
589 |
received frame(size= |
|
|
551 | received frame(size=901; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
590 | 552 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
591 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
592 | received frame(size=431; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) | |
|
593 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) | |
|
594 | 553 | updating the branch cache |
|
595 | 554 | new changesets 3390ef850073:caa2a465451d (1 drafts) |
|
596 | 555 | (sent 5 HTTP requests and * bytes; received * bytes in responses) (glob) |
|
597 | 556 | |
|
598 | 557 | $ hg -R client-bookmarks bookmarks |
|
599 | 558 | book-1 0:3390ef850073 |
|
600 | 559 | book-2 2:cd2534766bec |
|
601 | 560 | |
|
602 | 561 | Server-side bookmark moves are reflected during `hg pull` |
|
603 | 562 | |
|
604 | 563 | $ hg -R server-simple bookmark -r cd2534766bece138c7c1afdc6825302f0f62d81f book-1 |
|
605 | 564 | moving bookmark 'book-1' forward from 3390ef850073 |
|
606 | 565 | |
|
607 | 566 | $ hg -R client-bookmarks --debug pull |
|
608 | 567 | pulling from http://localhost:$HGPORT/ |
|
609 | 568 | using http://localhost:$HGPORT/ |
|
610 | 569 | sending capabilities command |
|
611 | 570 | query 1; heads |
|
612 | 571 | sending 2 commands |
|
613 | 572 | sending command heads: {} |
|
614 | 573 | sending command known: { |
|
615 | 574 | 'nodes': [ |
|
616 | 575 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f', |
|
617 | 576 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1' |
|
618 | 577 | ] |
|
619 | 578 | } |
|
620 | 579 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
621 | 580 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
622 | 581 | received frame(size=43; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
623 | 582 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
624 | 583 | received frame(size=11; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
625 | 584 | received frame(size=3; request=3; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
626 | 585 | received frame(size=0; request=3; stream=2; streamflags=; type=command-response; flags=eos) |
|
627 | 586 | searching for changes |
|
628 | 587 | all remote heads known locally |
|
629 | 588 | sending 1 commands |
|
630 | 589 | sending command changesetdata: { |
|
631 | 590 | 'fields': set([ |
|
632 | 591 | 'bookmarks', |
|
633 | 592 | 'parents', |
|
634 | 593 | 'phase', |
|
635 | 594 | 'revision' |
|
636 | 595 | ]), |
|
637 | 596 | 'revisions': [ |
|
638 | 597 | { |
|
639 | 598 | 'heads': [ |
|
640 | 599 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1', |
|
641 | 600 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f' |
|
642 | 601 | ], |
|
643 | 602 | 'roots': [ |
|
644 | 603 | '\xca\xa2\xa4eE\x1d\xd1\xfa\xcd\xa0\xf5\xb1#\x12\xc3UXA\x88\xa1', |
|
645 | 604 | '\xcd%4vk\xec\xe18\xc7\xc1\xaf\xdch%0/\x0fb\xd8\x1f' |
|
646 | 605 | ], |
|
647 | 606 | 'type': 'changesetdagrange' |
|
648 | 607 | } |
|
649 | 608 | ] |
|
650 | 609 | } |
|
651 | 610 | received frame(size=9; request=1; stream=2; streamflags=stream-begin; type=stream-settings; flags=eos) |
|
652 | 611 | received frame(size=11; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
653 | 612 | received frame(size=65; request=1; stream=2; streamflags=encoded; type=command-response; flags=continuation) |
|
654 | 613 | received frame(size=0; request=1; stream=2; streamflags=; type=command-response; flags=eos) |
|
655 | 614 | checking for updated bookmarks |
|
656 | 615 | updating bookmark book-1 |
|
657 | 616 | (run 'hg update' to get a working copy) |
|
658 | 617 | (sent 3 HTTP requests and * bytes; received * bytes in responses) (glob) |
|
659 | 618 | |
|
660 | 619 | $ hg -R client-bookmarks bookmarks |
|
661 | 620 | book-1 2:cd2534766bec |
|
662 | 621 | book-2 2:cd2534766bec |
General Comments 0
You need to be logged in to leave comments.
Login now