##// END OF EJS Templates
rollback: fix off-by-one in message
Matt Mackall -
r11174:ba78a1bf default
parent child Browse files
Show More
@@ -1,2291 +1,2291 b''
1 1 # localrepo.py - read/write repository class for mercurial
2 2 #
3 3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.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 node import bin, hex, nullid, nullrev, short
9 9 from i18n import _
10 10 import repo, changegroup, subrepo
11 11 import changelog, dirstate, filelog, manifest, context
12 12 import lock, transaction, store, encoding
13 13 import util, extensions, hook, error
14 14 import match as matchmod
15 15 import merge as mergemod
16 16 import tags as tagsmod
17 17 import url as urlmod
18 18 from lock import release
19 19 import weakref, stat, errno, os, time, inspect
20 20 propertycache = util.propertycache
21 21
22 22 class localrepository(repo.repository):
23 23 capabilities = set(('lookup', 'changegroupsubset', 'branchmap'))
24 24 supported = set('revlogv1 store fncache shared'.split())
25 25
26 26 def __init__(self, baseui, path=None, create=0):
27 27 repo.repository.__init__(self)
28 28 self.root = os.path.realpath(util.expandpath(path))
29 29 self.path = os.path.join(self.root, ".hg")
30 30 self.origroot = path
31 31 self.opener = util.opener(self.path)
32 32 self.wopener = util.opener(self.root)
33 33 self.baseui = baseui
34 34 self.ui = baseui.copy()
35 35
36 36 try:
37 37 self.ui.readconfig(self.join("hgrc"), self.root)
38 38 extensions.loadall(self.ui)
39 39 except IOError:
40 40 pass
41 41
42 42 if not os.path.isdir(self.path):
43 43 if create:
44 44 if not os.path.exists(path):
45 45 os.mkdir(path)
46 46 os.mkdir(self.path)
47 47 requirements = ["revlogv1"]
48 48 if self.ui.configbool('format', 'usestore', True):
49 49 os.mkdir(os.path.join(self.path, "store"))
50 50 requirements.append("store")
51 51 if self.ui.configbool('format', 'usefncache', True):
52 52 requirements.append("fncache")
53 53 # create an invalid changelog
54 54 self.opener("00changelog.i", "a").write(
55 55 '\0\0\0\2' # represents revlogv2
56 56 ' dummy changelog to prevent using the old repo layout'
57 57 )
58 58 reqfile = self.opener("requires", "w")
59 59 for r in requirements:
60 60 reqfile.write("%s\n" % r)
61 61 reqfile.close()
62 62 else:
63 63 raise error.RepoError(_("repository %s not found") % path)
64 64 elif create:
65 65 raise error.RepoError(_("repository %s already exists") % path)
66 66 else:
67 67 # find requirements
68 68 requirements = set()
69 69 try:
70 70 requirements = set(self.opener("requires").read().splitlines())
71 71 except IOError, inst:
72 72 if inst.errno != errno.ENOENT:
73 73 raise
74 74 for r in requirements - self.supported:
75 75 raise error.RepoError(_("requirement '%s' not supported") % r)
76 76
77 77 self.sharedpath = self.path
78 78 try:
79 79 s = os.path.realpath(self.opener("sharedpath").read())
80 80 if not os.path.exists(s):
81 81 raise error.RepoError(
82 82 _('.hg/sharedpath points to nonexistent directory %s') % s)
83 83 self.sharedpath = s
84 84 except IOError, inst:
85 85 if inst.errno != errno.ENOENT:
86 86 raise
87 87
88 88 self.store = store.store(requirements, self.sharedpath, util.opener)
89 89 self.spath = self.store.path
90 90 self.sopener = self.store.opener
91 91 self.sjoin = self.store.join
92 92 self.opener.createmode = self.store.createmode
93 93 self.sopener.options = {}
94 94
95 95 # These two define the set of tags for this repository. _tags
96 96 # maps tag name to node; _tagtypes maps tag name to 'global' or
97 97 # 'local'. (Global tags are defined by .hgtags across all
98 98 # heads, and local tags are defined in .hg/localtags.) They
99 99 # constitute the in-memory cache of tags.
100 100 self._tags = None
101 101 self._tagtypes = None
102 102
103 103 self._branchcache = None # in UTF-8
104 104 self._branchcachetip = None
105 105 self.nodetagscache = None
106 106 self.filterpats = {}
107 107 self._datafilters = {}
108 108 self._transref = self._lockref = self._wlockref = None
109 109
110 110 @propertycache
111 111 def changelog(self):
112 112 c = changelog.changelog(self.sopener)
113 113 if 'HG_PENDING' in os.environ:
114 114 p = os.environ['HG_PENDING']
115 115 if p.startswith(self.root):
116 116 c.readpending('00changelog.i.a')
117 117 self.sopener.options['defversion'] = c.version
118 118 return c
119 119
120 120 @propertycache
121 121 def manifest(self):
122 122 return manifest.manifest(self.sopener)
123 123
124 124 @propertycache
125 125 def dirstate(self):
126 126 return dirstate.dirstate(self.opener, self.ui, self.root)
127 127
128 128 def __getitem__(self, changeid):
129 129 if changeid is None:
130 130 return context.workingctx(self)
131 131 return context.changectx(self, changeid)
132 132
133 133 def __contains__(self, changeid):
134 134 try:
135 135 return bool(self.lookup(changeid))
136 136 except error.RepoLookupError:
137 137 return False
138 138
139 139 def __nonzero__(self):
140 140 return True
141 141
142 142 def __len__(self):
143 143 return len(self.changelog)
144 144
145 145 def __iter__(self):
146 146 for i in xrange(len(self)):
147 147 yield i
148 148
149 149 def url(self):
150 150 return 'file:' + self.root
151 151
152 152 def hook(self, name, throw=False, **args):
153 153 return hook.hook(self.ui, self, name, throw, **args)
154 154
155 155 tag_disallowed = ':\r\n'
156 156
157 157 def _tag(self, names, node, message, local, user, date, extra={}):
158 158 if isinstance(names, str):
159 159 allchars = names
160 160 names = (names,)
161 161 else:
162 162 allchars = ''.join(names)
163 163 for c in self.tag_disallowed:
164 164 if c in allchars:
165 165 raise util.Abort(_('%r cannot be used in a tag name') % c)
166 166
167 167 branches = self.branchmap()
168 168 for name in names:
169 169 self.hook('pretag', throw=True, node=hex(node), tag=name,
170 170 local=local)
171 171 if name in branches:
172 172 self.ui.warn(_("warning: tag %s conflicts with existing"
173 173 " branch name\n") % name)
174 174
175 175 def writetags(fp, names, munge, prevtags):
176 176 fp.seek(0, 2)
177 177 if prevtags and prevtags[-1] != '\n':
178 178 fp.write('\n')
179 179 for name in names:
180 180 m = munge and munge(name) or name
181 181 if self._tagtypes and name in self._tagtypes:
182 182 old = self._tags.get(name, nullid)
183 183 fp.write('%s %s\n' % (hex(old), m))
184 184 fp.write('%s %s\n' % (hex(node), m))
185 185 fp.close()
186 186
187 187 prevtags = ''
188 188 if local:
189 189 try:
190 190 fp = self.opener('localtags', 'r+')
191 191 except IOError:
192 192 fp = self.opener('localtags', 'a')
193 193 else:
194 194 prevtags = fp.read()
195 195
196 196 # local tags are stored in the current charset
197 197 writetags(fp, names, None, prevtags)
198 198 for name in names:
199 199 self.hook('tag', node=hex(node), tag=name, local=local)
200 200 return
201 201
202 202 try:
203 203 fp = self.wfile('.hgtags', 'rb+')
204 204 except IOError:
205 205 fp = self.wfile('.hgtags', 'ab')
206 206 else:
207 207 prevtags = fp.read()
208 208
209 209 # committed tags are stored in UTF-8
210 210 writetags(fp, names, encoding.fromlocal, prevtags)
211 211
212 212 if '.hgtags' not in self.dirstate:
213 213 self.add(['.hgtags'])
214 214
215 215 m = matchmod.exact(self.root, '', ['.hgtags'])
216 216 tagnode = self.commit(message, user, date, extra=extra, match=m)
217 217
218 218 for name in names:
219 219 self.hook('tag', node=hex(node), tag=name, local=local)
220 220
221 221 return tagnode
222 222
223 223 def tag(self, names, node, message, local, user, date):
224 224 '''tag a revision with one or more symbolic names.
225 225
226 226 names is a list of strings or, when adding a single tag, names may be a
227 227 string.
228 228
229 229 if local is True, the tags are stored in a per-repository file.
230 230 otherwise, they are stored in the .hgtags file, and a new
231 231 changeset is committed with the change.
232 232
233 233 keyword arguments:
234 234
235 235 local: whether to store tags in non-version-controlled file
236 236 (default False)
237 237
238 238 message: commit message to use if committing
239 239
240 240 user: name of user to use if committing
241 241
242 242 date: date tuple to use if committing'''
243 243
244 244 for x in self.status()[:5]:
245 245 if '.hgtags' in x:
246 246 raise util.Abort(_('working copy of .hgtags is changed '
247 247 '(please commit .hgtags manually)'))
248 248
249 249 self.tags() # instantiate the cache
250 250 self._tag(names, node, message, local, user, date)
251 251
252 252 def tags(self):
253 253 '''return a mapping of tag to node'''
254 254 if self._tags is None:
255 255 (self._tags, self._tagtypes) = self._findtags()
256 256
257 257 return self._tags
258 258
259 259 def _findtags(self):
260 260 '''Do the hard work of finding tags. Return a pair of dicts
261 261 (tags, tagtypes) where tags maps tag name to node, and tagtypes
262 262 maps tag name to a string like \'global\' or \'local\'.
263 263 Subclasses or extensions are free to add their own tags, but
264 264 should be aware that the returned dicts will be retained for the
265 265 duration of the localrepo object.'''
266 266
267 267 # XXX what tagtype should subclasses/extensions use? Currently
268 268 # mq and bookmarks add tags, but do not set the tagtype at all.
269 269 # Should each extension invent its own tag type? Should there
270 270 # be one tagtype for all such "virtual" tags? Or is the status
271 271 # quo fine?
272 272
273 273 alltags = {} # map tag name to (node, hist)
274 274 tagtypes = {}
275 275
276 276 tagsmod.findglobaltags(self.ui, self, alltags, tagtypes)
277 277 tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
278 278
279 279 # Build the return dicts. Have to re-encode tag names because
280 280 # the tags module always uses UTF-8 (in order not to lose info
281 281 # writing to the cache), but the rest of Mercurial wants them in
282 282 # local encoding.
283 283 tags = {}
284 284 for (name, (node, hist)) in alltags.iteritems():
285 285 if node != nullid:
286 286 tags[encoding.tolocal(name)] = node
287 287 tags['tip'] = self.changelog.tip()
288 288 tagtypes = dict([(encoding.tolocal(name), value)
289 289 for (name, value) in tagtypes.iteritems()])
290 290 return (tags, tagtypes)
291 291
292 292 def tagtype(self, tagname):
293 293 '''
294 294 return the type of the given tag. result can be:
295 295
296 296 'local' : a local tag
297 297 'global' : a global tag
298 298 None : tag does not exist
299 299 '''
300 300
301 301 self.tags()
302 302
303 303 return self._tagtypes.get(tagname)
304 304
305 305 def tagslist(self):
306 306 '''return a list of tags ordered by revision'''
307 307 l = []
308 308 for t, n in self.tags().iteritems():
309 309 try:
310 310 r = self.changelog.rev(n)
311 311 except:
312 312 r = -2 # sort to the beginning of the list if unknown
313 313 l.append((r, t, n))
314 314 return [(t, n) for r, t, n in sorted(l)]
315 315
316 316 def nodetags(self, node):
317 317 '''return the tags associated with a node'''
318 318 if not self.nodetagscache:
319 319 self.nodetagscache = {}
320 320 for t, n in self.tags().iteritems():
321 321 self.nodetagscache.setdefault(n, []).append(t)
322 322 for tags in self.nodetagscache.itervalues():
323 323 tags.sort()
324 324 return self.nodetagscache.get(node, [])
325 325
326 326 def _branchtags(self, partial, lrev):
327 327 # TODO: rename this function?
328 328 tiprev = len(self) - 1
329 329 if lrev != tiprev:
330 330 ctxgen = (self[r] for r in xrange(lrev + 1, tiprev + 1))
331 331 self._updatebranchcache(partial, ctxgen)
332 332 self._writebranchcache(partial, self.changelog.tip(), tiprev)
333 333
334 334 return partial
335 335
336 336 def branchmap(self):
337 337 '''returns a dictionary {branch: [branchheads]}'''
338 338 tip = self.changelog.tip()
339 339 if self._branchcache is not None and self._branchcachetip == tip:
340 340 return self._branchcache
341 341
342 342 oldtip = self._branchcachetip
343 343 self._branchcachetip = tip
344 344 if oldtip is None or oldtip not in self.changelog.nodemap:
345 345 partial, last, lrev = self._readbranchcache()
346 346 else:
347 347 lrev = self.changelog.rev(oldtip)
348 348 partial = self._branchcache
349 349
350 350 self._branchtags(partial, lrev)
351 351 # this private cache holds all heads (not just tips)
352 352 self._branchcache = partial
353 353
354 354 return self._branchcache
355 355
356 356 def branchtags(self):
357 357 '''return a dict where branch names map to the tipmost head of
358 358 the branch, open heads come before closed'''
359 359 bt = {}
360 360 for bn, heads in self.branchmap().iteritems():
361 361 tip = heads[-1]
362 362 for h in reversed(heads):
363 363 if 'close' not in self.changelog.read(h)[5]:
364 364 tip = h
365 365 break
366 366 bt[bn] = tip
367 367 return bt
368 368
369 369
370 370 def _readbranchcache(self):
371 371 partial = {}
372 372 try:
373 373 f = self.opener("branchheads.cache")
374 374 lines = f.read().split('\n')
375 375 f.close()
376 376 except (IOError, OSError):
377 377 return {}, nullid, nullrev
378 378
379 379 try:
380 380 last, lrev = lines.pop(0).split(" ", 1)
381 381 last, lrev = bin(last), int(lrev)
382 382 if lrev >= len(self) or self[lrev].node() != last:
383 383 # invalidate the cache
384 384 raise ValueError('invalidating branch cache (tip differs)')
385 385 for l in lines:
386 386 if not l:
387 387 continue
388 388 node, label = l.split(" ", 1)
389 389 partial.setdefault(label.strip(), []).append(bin(node))
390 390 except KeyboardInterrupt:
391 391 raise
392 392 except Exception, inst:
393 393 if self.ui.debugflag:
394 394 self.ui.warn(str(inst), '\n')
395 395 partial, last, lrev = {}, nullid, nullrev
396 396 return partial, last, lrev
397 397
398 398 def _writebranchcache(self, branches, tip, tiprev):
399 399 try:
400 400 f = self.opener("branchheads.cache", "w", atomictemp=True)
401 401 f.write("%s %s\n" % (hex(tip), tiprev))
402 402 for label, nodes in branches.iteritems():
403 403 for node in nodes:
404 404 f.write("%s %s\n" % (hex(node), label))
405 405 f.rename()
406 406 except (IOError, OSError):
407 407 pass
408 408
409 409 def _updatebranchcache(self, partial, ctxgen):
410 410 # collect new branch entries
411 411 newbranches = {}
412 412 for c in ctxgen:
413 413 newbranches.setdefault(c.branch(), []).append(c.node())
414 414 # if older branchheads are reachable from new ones, they aren't
415 415 # really branchheads. Note checking parents is insufficient:
416 416 # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
417 417 for branch, newnodes in newbranches.iteritems():
418 418 bheads = partial.setdefault(branch, [])
419 419 bheads.extend(newnodes)
420 420 if len(bheads) <= 1:
421 421 continue
422 422 # starting from tip means fewer passes over reachable
423 423 while newnodes:
424 424 latest = newnodes.pop()
425 425 if latest not in bheads:
426 426 continue
427 427 minbhrev = self[min([self[bh].rev() for bh in bheads])].node()
428 428 reachable = self.changelog.reachable(latest, minbhrev)
429 429 reachable.remove(latest)
430 430 bheads = [b for b in bheads if b not in reachable]
431 431 partial[branch] = bheads
432 432
433 433 def lookup(self, key):
434 434 if isinstance(key, int):
435 435 return self.changelog.node(key)
436 436 elif key == '.':
437 437 return self.dirstate.parents()[0]
438 438 elif key == 'null':
439 439 return nullid
440 440 elif key == 'tip':
441 441 return self.changelog.tip()
442 442 n = self.changelog._match(key)
443 443 if n:
444 444 return n
445 445 if key in self.tags():
446 446 return self.tags()[key]
447 447 if key in self.branchtags():
448 448 return self.branchtags()[key]
449 449 n = self.changelog._partialmatch(key)
450 450 if n:
451 451 return n
452 452
453 453 # can't find key, check if it might have come from damaged dirstate
454 454 if key in self.dirstate.parents():
455 455 raise error.Abort(_("working directory has unknown parent '%s'!")
456 456 % short(key))
457 457 try:
458 458 if len(key) == 20:
459 459 key = hex(key)
460 460 except:
461 461 pass
462 462 raise error.RepoLookupError(_("unknown revision '%s'") % key)
463 463
464 464 def lookupbranch(self, key, remote=None):
465 465 repo = remote or self
466 466 if key in repo.branchmap():
467 467 return key
468 468
469 469 repo = (remote and remote.local()) and remote or self
470 470 return repo[key].branch()
471 471
472 472 def local(self):
473 473 return True
474 474
475 475 def join(self, f):
476 476 return os.path.join(self.path, f)
477 477
478 478 def wjoin(self, f):
479 479 return os.path.join(self.root, f)
480 480
481 481 def rjoin(self, f):
482 482 return os.path.join(self.root, util.pconvert(f))
483 483
484 484 def file(self, f):
485 485 if f[0] == '/':
486 486 f = f[1:]
487 487 return filelog.filelog(self.sopener, f)
488 488
489 489 def changectx(self, changeid):
490 490 return self[changeid]
491 491
492 492 def parents(self, changeid=None):
493 493 '''get list of changectxs for parents of changeid'''
494 494 return self[changeid].parents()
495 495
496 496 def filectx(self, path, changeid=None, fileid=None):
497 497 """changeid can be a changeset revision, node, or tag.
498 498 fileid can be a file revision or node."""
499 499 return context.filectx(self, path, changeid, fileid)
500 500
501 501 def getcwd(self):
502 502 return self.dirstate.getcwd()
503 503
504 504 def pathto(self, f, cwd=None):
505 505 return self.dirstate.pathto(f, cwd)
506 506
507 507 def wfile(self, f, mode='r'):
508 508 return self.wopener(f, mode)
509 509
510 510 def _link(self, f):
511 511 return os.path.islink(self.wjoin(f))
512 512
513 513 def _filter(self, filter, filename, data):
514 514 if filter not in self.filterpats:
515 515 l = []
516 516 for pat, cmd in self.ui.configitems(filter):
517 517 if cmd == '!':
518 518 continue
519 519 mf = matchmod.match(self.root, '', [pat])
520 520 fn = None
521 521 params = cmd
522 522 for name, filterfn in self._datafilters.iteritems():
523 523 if cmd.startswith(name):
524 524 fn = filterfn
525 525 params = cmd[len(name):].lstrip()
526 526 break
527 527 if not fn:
528 528 fn = lambda s, c, **kwargs: util.filter(s, c)
529 529 # Wrap old filters not supporting keyword arguments
530 530 if not inspect.getargspec(fn)[2]:
531 531 oldfn = fn
532 532 fn = lambda s, c, **kwargs: oldfn(s, c)
533 533 l.append((mf, fn, params))
534 534 self.filterpats[filter] = l
535 535
536 536 for mf, fn, cmd in self.filterpats[filter]:
537 537 if mf(filename):
538 538 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
539 539 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
540 540 break
541 541
542 542 return data
543 543
544 544 def adddatafilter(self, name, filter):
545 545 self._datafilters[name] = filter
546 546
547 547 def wread(self, filename):
548 548 if self._link(filename):
549 549 data = os.readlink(self.wjoin(filename))
550 550 else:
551 551 data = self.wopener(filename, 'r').read()
552 552 return self._filter("encode", filename, data)
553 553
554 554 def wwrite(self, filename, data, flags):
555 555 data = self._filter("decode", filename, data)
556 556 try:
557 557 os.unlink(self.wjoin(filename))
558 558 except OSError:
559 559 pass
560 560 if 'l' in flags:
561 561 self.wopener.symlink(data, filename)
562 562 else:
563 563 self.wopener(filename, 'w').write(data)
564 564 if 'x' in flags:
565 565 util.set_flags(self.wjoin(filename), False, True)
566 566
567 567 def wwritedata(self, filename, data):
568 568 return self._filter("decode", filename, data)
569 569
570 570 def transaction(self, desc):
571 571 tr = self._transref and self._transref() or None
572 572 if tr and tr.running():
573 573 return tr.nest()
574 574
575 575 # abort here if the journal already exists
576 576 if os.path.exists(self.sjoin("journal")):
577 577 raise error.RepoError(
578 578 _("abandoned transaction found - run hg recover"))
579 579
580 580 # save dirstate for rollback
581 581 try:
582 582 ds = self.opener("dirstate").read()
583 583 except IOError:
584 584 ds = ""
585 585 self.opener("journal.dirstate", "w").write(ds)
586 586 self.opener("journal.branch", "w").write(self.dirstate.branch())
587 587 self.opener("journal.desc", "w").write("%d\n%s\n" % (len(self), desc))
588 588
589 589 renames = [(self.sjoin("journal"), self.sjoin("undo")),
590 590 (self.join("journal.dirstate"), self.join("undo.dirstate")),
591 591 (self.join("journal.branch"), self.join("undo.branch")),
592 592 (self.join("journal.desc"), self.join("undo.desc"))]
593 593 tr = transaction.transaction(self.ui.warn, self.sopener,
594 594 self.sjoin("journal"),
595 595 aftertrans(renames),
596 596 self.store.createmode)
597 597 self._transref = weakref.ref(tr)
598 598 return tr
599 599
600 600 def recover(self):
601 601 lock = self.lock()
602 602 try:
603 603 if os.path.exists(self.sjoin("journal")):
604 604 self.ui.status(_("rolling back interrupted transaction\n"))
605 605 transaction.rollback(self.sopener, self.sjoin("journal"),
606 606 self.ui.warn)
607 607 self.invalidate()
608 608 return True
609 609 else:
610 610 self.ui.warn(_("no interrupted transaction available\n"))
611 611 return False
612 612 finally:
613 613 lock.release()
614 614
615 615 def rollback(self, dryrun=False):
616 616 wlock = lock = None
617 617 try:
618 618 wlock = self.wlock()
619 619 lock = self.lock()
620 620 if os.path.exists(self.sjoin("undo")):
621 621 try:
622 622 args = self.opener("undo.desc", "r").read().splitlines()
623 623 if len(args) >= 3 and self.ui.verbose:
624 624 desc = _("rolling back to revision %s"
625 625 " (undo %s: %s)\n") % (
626 args[0], args[1], args[2])
626 int(args[0]) - 1, args[1], args[2])
627 627 elif len(args) >= 2:
628 628 desc = _("rolling back to revision %s (undo %s)\n") % (
629 args[0], args[1])
629 int(args[0]) - 1, args[1])
630 630 except IOError:
631 631 desc = _("rolling back unknown transaction\n")
632 632 self.ui.status(desc)
633 633 if dryrun:
634 634 return
635 635 transaction.rollback(self.sopener, self.sjoin("undo"),
636 636 self.ui.warn)
637 637 util.rename(self.join("undo.dirstate"), self.join("dirstate"))
638 638 try:
639 639 branch = self.opener("undo.branch").read()
640 640 self.dirstate.setbranch(branch)
641 641 except IOError:
642 642 self.ui.warn(_("Named branch could not be reset, "
643 643 "current branch still is: %s\n")
644 644 % encoding.tolocal(self.dirstate.branch()))
645 645 self.invalidate()
646 646 self.dirstate.invalidate()
647 647 self.destroyed()
648 648 else:
649 649 self.ui.warn(_("no rollback information available\n"))
650 650 finally:
651 651 release(lock, wlock)
652 652
653 653 def invalidatecaches(self):
654 654 self._tags = None
655 655 self._tagtypes = None
656 656 self.nodetagscache = None
657 657 self._branchcache = None # in UTF-8
658 658 self._branchcachetip = None
659 659
660 660 def invalidate(self):
661 661 for a in "changelog manifest".split():
662 662 if a in self.__dict__:
663 663 delattr(self, a)
664 664 self.invalidatecaches()
665 665
666 666 def _lock(self, lockname, wait, releasefn, acquirefn, desc):
667 667 try:
668 668 l = lock.lock(lockname, 0, releasefn, desc=desc)
669 669 except error.LockHeld, inst:
670 670 if not wait:
671 671 raise
672 672 self.ui.warn(_("waiting for lock on %s held by %r\n") %
673 673 (desc, inst.locker))
674 674 # default to 600 seconds timeout
675 675 l = lock.lock(lockname, int(self.ui.config("ui", "timeout", "600")),
676 676 releasefn, desc=desc)
677 677 if acquirefn:
678 678 acquirefn()
679 679 return l
680 680
681 681 def lock(self, wait=True):
682 682 '''Lock the repository store (.hg/store) and return a weak reference
683 683 to the lock. Use this before modifying the store (e.g. committing or
684 684 stripping). If you are opening a transaction, get a lock as well.)'''
685 685 l = self._lockref and self._lockref()
686 686 if l is not None and l.held:
687 687 l.lock()
688 688 return l
689 689
690 690 l = self._lock(self.sjoin("lock"), wait, None, self.invalidate,
691 691 _('repository %s') % self.origroot)
692 692 self._lockref = weakref.ref(l)
693 693 return l
694 694
695 695 def wlock(self, wait=True):
696 696 '''Lock the non-store parts of the repository (everything under
697 697 .hg except .hg/store) and return a weak reference to the lock.
698 698 Use this before modifying files in .hg.'''
699 699 l = self._wlockref and self._wlockref()
700 700 if l is not None and l.held:
701 701 l.lock()
702 702 return l
703 703
704 704 l = self._lock(self.join("wlock"), wait, self.dirstate.write,
705 705 self.dirstate.invalidate, _('working directory of %s') %
706 706 self.origroot)
707 707 self._wlockref = weakref.ref(l)
708 708 return l
709 709
710 710 def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
711 711 """
712 712 commit an individual file as part of a larger transaction
713 713 """
714 714
715 715 fname = fctx.path()
716 716 text = fctx.data()
717 717 flog = self.file(fname)
718 718 fparent1 = manifest1.get(fname, nullid)
719 719 fparent2 = fparent2o = manifest2.get(fname, nullid)
720 720
721 721 meta = {}
722 722 copy = fctx.renamed()
723 723 if copy and copy[0] != fname:
724 724 # Mark the new revision of this file as a copy of another
725 725 # file. This copy data will effectively act as a parent
726 726 # of this new revision. If this is a merge, the first
727 727 # parent will be the nullid (meaning "look up the copy data")
728 728 # and the second one will be the other parent. For example:
729 729 #
730 730 # 0 --- 1 --- 3 rev1 changes file foo
731 731 # \ / rev2 renames foo to bar and changes it
732 732 # \- 2 -/ rev3 should have bar with all changes and
733 733 # should record that bar descends from
734 734 # bar in rev2 and foo in rev1
735 735 #
736 736 # this allows this merge to succeed:
737 737 #
738 738 # 0 --- 1 --- 3 rev4 reverts the content change from rev2
739 739 # \ / merging rev3 and rev4 should use bar@rev2
740 740 # \- 2 --- 4 as the merge base
741 741 #
742 742
743 743 cfname = copy[0]
744 744 crev = manifest1.get(cfname)
745 745 newfparent = fparent2
746 746
747 747 if manifest2: # branch merge
748 748 if fparent2 == nullid or crev is None: # copied on remote side
749 749 if cfname in manifest2:
750 750 crev = manifest2[cfname]
751 751 newfparent = fparent1
752 752
753 753 # find source in nearest ancestor if we've lost track
754 754 if not crev:
755 755 self.ui.debug(" %s: searching for copy revision for %s\n" %
756 756 (fname, cfname))
757 757 for ancestor in self['.'].ancestors():
758 758 if cfname in ancestor:
759 759 crev = ancestor[cfname].filenode()
760 760 break
761 761
762 762 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
763 763 meta["copy"] = cfname
764 764 meta["copyrev"] = hex(crev)
765 765 fparent1, fparent2 = nullid, newfparent
766 766 elif fparent2 != nullid:
767 767 # is one parent an ancestor of the other?
768 768 fparentancestor = flog.ancestor(fparent1, fparent2)
769 769 if fparentancestor == fparent1:
770 770 fparent1, fparent2 = fparent2, nullid
771 771 elif fparentancestor == fparent2:
772 772 fparent2 = nullid
773 773
774 774 # is the file changed?
775 775 if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
776 776 changelist.append(fname)
777 777 return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
778 778
779 779 # are just the flags changed during merge?
780 780 if fparent1 != fparent2o and manifest1.flags(fname) != fctx.flags():
781 781 changelist.append(fname)
782 782
783 783 return fparent1
784 784
785 785 def commit(self, text="", user=None, date=None, match=None, force=False,
786 786 editor=False, extra={}):
787 787 """Add a new revision to current repository.
788 788
789 789 Revision information is gathered from the working directory,
790 790 match can be used to filter the committed files. If editor is
791 791 supplied, it is called to get a commit message.
792 792 """
793 793
794 794 def fail(f, msg):
795 795 raise util.Abort('%s: %s' % (f, msg))
796 796
797 797 if not match:
798 798 match = matchmod.always(self.root, '')
799 799
800 800 if not force:
801 801 vdirs = []
802 802 match.dir = vdirs.append
803 803 match.bad = fail
804 804
805 805 wlock = self.wlock()
806 806 try:
807 807 wctx = self[None]
808 808 merge = len(wctx.parents()) > 1
809 809
810 810 if (not force and merge and match and
811 811 (match.files() or match.anypats())):
812 812 raise util.Abort(_('cannot partially commit a merge '
813 813 '(do not specify files or patterns)'))
814 814
815 815 changes = self.status(match=match, clean=force)
816 816 if force:
817 817 changes[0].extend(changes[6]) # mq may commit unchanged files
818 818
819 819 # check subrepos
820 820 subs = []
821 821 removedsubs = set()
822 822 for p in wctx.parents():
823 823 removedsubs.update(s for s in p.substate if match(s))
824 824 for s in wctx.substate:
825 825 removedsubs.discard(s)
826 826 if match(s) and wctx.sub(s).dirty():
827 827 subs.append(s)
828 828 if (subs or removedsubs) and '.hgsubstate' not in changes[0]:
829 829 changes[0].insert(0, '.hgsubstate')
830 830
831 831 # make sure all explicit patterns are matched
832 832 if not force and match.files():
833 833 matched = set(changes[0] + changes[1] + changes[2])
834 834
835 835 for f in match.files():
836 836 if f == '.' or f in matched or f in wctx.substate:
837 837 continue
838 838 if f in changes[3]: # missing
839 839 fail(f, _('file not found!'))
840 840 if f in vdirs: # visited directory
841 841 d = f + '/'
842 842 for mf in matched:
843 843 if mf.startswith(d):
844 844 break
845 845 else:
846 846 fail(f, _("no match under directory!"))
847 847 elif f not in self.dirstate:
848 848 fail(f, _("file not tracked!"))
849 849
850 850 if (not force and not extra.get("close") and not merge
851 851 and not (changes[0] or changes[1] or changes[2])
852 852 and wctx.branch() == wctx.p1().branch()):
853 853 return None
854 854
855 855 ms = mergemod.mergestate(self)
856 856 for f in changes[0]:
857 857 if f in ms and ms[f] == 'u':
858 858 raise util.Abort(_("unresolved merge conflicts "
859 859 "(see hg resolve)"))
860 860
861 861 cctx = context.workingctx(self, text, user, date, extra, changes)
862 862 if editor:
863 863 cctx._text = editor(self, cctx, subs)
864 864 edited = (text != cctx._text)
865 865
866 866 # commit subs
867 867 if subs or removedsubs:
868 868 state = wctx.substate.copy()
869 869 for s in subs:
870 870 sub = wctx.sub(s)
871 871 self.ui.status(_('committing subrepository %s\n') %
872 872 subrepo.relpath(sub))
873 873 sr = sub.commit(cctx._text, user, date)
874 874 state[s] = (state[s][0], sr)
875 875 subrepo.writestate(self, state)
876 876
877 877 # Save commit message in case this transaction gets rolled back
878 878 # (e.g. by a pretxncommit hook). Leave the content alone on
879 879 # the assumption that the user will use the same editor again.
880 880 msgfile = self.opener('last-message.txt', 'wb')
881 881 msgfile.write(cctx._text)
882 882 msgfile.close()
883 883
884 884 p1, p2 = self.dirstate.parents()
885 885 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
886 886 try:
887 887 self.hook("precommit", throw=True, parent1=hookp1, parent2=hookp2)
888 888 ret = self.commitctx(cctx, True)
889 889 except:
890 890 if edited:
891 891 msgfn = self.pathto(msgfile.name[len(self.root)+1:])
892 892 self.ui.write(
893 893 _('note: commit message saved in %s\n') % msgfn)
894 894 raise
895 895
896 896 # update dirstate and mergestate
897 897 for f in changes[0] + changes[1]:
898 898 self.dirstate.normal(f)
899 899 for f in changes[2]:
900 900 self.dirstate.forget(f)
901 901 self.dirstate.setparents(ret)
902 902 ms.reset()
903 903 finally:
904 904 wlock.release()
905 905
906 906 self.hook("commit", node=hex(ret), parent1=hookp1, parent2=hookp2)
907 907 return ret
908 908
909 909 def commitctx(self, ctx, error=False):
910 910 """Add a new revision to current repository.
911 911 Revision information is passed via the context argument.
912 912 """
913 913
914 914 tr = lock = None
915 915 removed = ctx.removed()
916 916 p1, p2 = ctx.p1(), ctx.p2()
917 917 m1 = p1.manifest().copy()
918 918 m2 = p2.manifest()
919 919 user = ctx.user()
920 920
921 921 lock = self.lock()
922 922 try:
923 923 tr = self.transaction("commit")
924 924 trp = weakref.proxy(tr)
925 925
926 926 # check in files
927 927 new = {}
928 928 changed = []
929 929 linkrev = len(self)
930 930 for f in sorted(ctx.modified() + ctx.added()):
931 931 self.ui.note(f + "\n")
932 932 try:
933 933 fctx = ctx[f]
934 934 new[f] = self._filecommit(fctx, m1, m2, linkrev, trp,
935 935 changed)
936 936 m1.set(f, fctx.flags())
937 937 except OSError, inst:
938 938 self.ui.warn(_("trouble committing %s!\n") % f)
939 939 raise
940 940 except IOError, inst:
941 941 errcode = getattr(inst, 'errno', errno.ENOENT)
942 942 if error or errcode and errcode != errno.ENOENT:
943 943 self.ui.warn(_("trouble committing %s!\n") % f)
944 944 raise
945 945 else:
946 946 removed.append(f)
947 947
948 948 # update manifest
949 949 m1.update(new)
950 950 removed = [f for f in sorted(removed) if f in m1 or f in m2]
951 951 drop = [f for f in removed if f in m1]
952 952 for f in drop:
953 953 del m1[f]
954 954 mn = self.manifest.add(m1, trp, linkrev, p1.manifestnode(),
955 955 p2.manifestnode(), (new, drop))
956 956
957 957 # update changelog
958 958 self.changelog.delayupdate()
959 959 n = self.changelog.add(mn, changed + removed, ctx.description(),
960 960 trp, p1.node(), p2.node(),
961 961 user, ctx.date(), ctx.extra().copy())
962 962 p = lambda: self.changelog.writepending() and self.root or ""
963 963 xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
964 964 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
965 965 parent2=xp2, pending=p)
966 966 self.changelog.finalize(trp)
967 967 tr.close()
968 968
969 969 if self._branchcache:
970 970 self.branchtags()
971 971 return n
972 972 finally:
973 973 del tr
974 974 lock.release()
975 975
976 976 def destroyed(self):
977 977 '''Inform the repository that nodes have been destroyed.
978 978 Intended for use by strip and rollback, so there's a common
979 979 place for anything that has to be done after destroying history.'''
980 980 # XXX it might be nice if we could take the list of destroyed
981 981 # nodes, but I don't see an easy way for rollback() to do that
982 982
983 983 # Ensure the persistent tag cache is updated. Doing it now
984 984 # means that the tag cache only has to worry about destroyed
985 985 # heads immediately after a strip/rollback. That in turn
986 986 # guarantees that "cachetip == currenttip" (comparing both rev
987 987 # and node) always means no nodes have been added or destroyed.
988 988
989 989 # XXX this is suboptimal when qrefresh'ing: we strip the current
990 990 # head, refresh the tag cache, then immediately add a new head.
991 991 # But I think doing it this way is necessary for the "instant
992 992 # tag cache retrieval" case to work.
993 993 self.invalidatecaches()
994 994
995 995 def walk(self, match, node=None):
996 996 '''
997 997 walk recursively through the directory tree or a given
998 998 changeset, finding all files matched by the match
999 999 function
1000 1000 '''
1001 1001 return self[node].walk(match)
1002 1002
1003 1003 def status(self, node1='.', node2=None, match=None,
1004 1004 ignored=False, clean=False, unknown=False):
1005 1005 """return status of files between two nodes or node and working directory
1006 1006
1007 1007 If node1 is None, use the first dirstate parent instead.
1008 1008 If node2 is None, compare node1 with working directory.
1009 1009 """
1010 1010
1011 1011 def mfmatches(ctx):
1012 1012 mf = ctx.manifest().copy()
1013 1013 for fn in mf.keys():
1014 1014 if not match(fn):
1015 1015 del mf[fn]
1016 1016 return mf
1017 1017
1018 1018 if isinstance(node1, context.changectx):
1019 1019 ctx1 = node1
1020 1020 else:
1021 1021 ctx1 = self[node1]
1022 1022 if isinstance(node2, context.changectx):
1023 1023 ctx2 = node2
1024 1024 else:
1025 1025 ctx2 = self[node2]
1026 1026
1027 1027 working = ctx2.rev() is None
1028 1028 parentworking = working and ctx1 == self['.']
1029 1029 match = match or matchmod.always(self.root, self.getcwd())
1030 1030 listignored, listclean, listunknown = ignored, clean, unknown
1031 1031
1032 1032 # load earliest manifest first for caching reasons
1033 1033 if not working and ctx2.rev() < ctx1.rev():
1034 1034 ctx2.manifest()
1035 1035
1036 1036 if not parentworking:
1037 1037 def bad(f, msg):
1038 1038 if f not in ctx1:
1039 1039 self.ui.warn('%s: %s\n' % (self.dirstate.pathto(f), msg))
1040 1040 match.bad = bad
1041 1041
1042 1042 if working: # we need to scan the working dir
1043 1043 subrepos = ctx1.substate.keys()
1044 1044 s = self.dirstate.status(match, subrepos, listignored,
1045 1045 listclean, listunknown)
1046 1046 cmp, modified, added, removed, deleted, unknown, ignored, clean = s
1047 1047
1048 1048 # check for any possibly clean files
1049 1049 if parentworking and cmp:
1050 1050 fixup = []
1051 1051 # do a full compare of any files that might have changed
1052 1052 for f in sorted(cmp):
1053 1053 if (f not in ctx1 or ctx2.flags(f) != ctx1.flags(f)
1054 1054 or ctx1[f].cmp(ctx2[f].data())):
1055 1055 modified.append(f)
1056 1056 else:
1057 1057 fixup.append(f)
1058 1058
1059 1059 if listclean:
1060 1060 clean += fixup
1061 1061
1062 1062 # update dirstate for files that are actually clean
1063 1063 if fixup:
1064 1064 try:
1065 1065 # updating the dirstate is optional
1066 1066 # so we don't wait on the lock
1067 1067 wlock = self.wlock(False)
1068 1068 try:
1069 1069 for f in fixup:
1070 1070 self.dirstate.normal(f)
1071 1071 finally:
1072 1072 wlock.release()
1073 1073 except error.LockError:
1074 1074 pass
1075 1075
1076 1076 if not parentworking:
1077 1077 mf1 = mfmatches(ctx1)
1078 1078 if working:
1079 1079 # we are comparing working dir against non-parent
1080 1080 # generate a pseudo-manifest for the working dir
1081 1081 mf2 = mfmatches(self['.'])
1082 1082 for f in cmp + modified + added:
1083 1083 mf2[f] = None
1084 1084 mf2.set(f, ctx2.flags(f))
1085 1085 for f in removed:
1086 1086 if f in mf2:
1087 1087 del mf2[f]
1088 1088 else:
1089 1089 # we are comparing two revisions
1090 1090 deleted, unknown, ignored = [], [], []
1091 1091 mf2 = mfmatches(ctx2)
1092 1092
1093 1093 modified, added, clean = [], [], []
1094 1094 for fn in mf2:
1095 1095 if fn in mf1:
1096 1096 if (mf1.flags(fn) != mf2.flags(fn) or
1097 1097 (mf1[fn] != mf2[fn] and
1098 1098 (mf2[fn] or ctx1[fn].cmp(ctx2[fn].data())))):
1099 1099 modified.append(fn)
1100 1100 elif listclean:
1101 1101 clean.append(fn)
1102 1102 del mf1[fn]
1103 1103 else:
1104 1104 added.append(fn)
1105 1105 removed = mf1.keys()
1106 1106
1107 1107 r = modified, added, removed, deleted, unknown, ignored, clean
1108 1108 [l.sort() for l in r]
1109 1109 return r
1110 1110
1111 1111 def add(self, list):
1112 1112 wlock = self.wlock()
1113 1113 try:
1114 1114 rejected = []
1115 1115 for f in list:
1116 1116 p = self.wjoin(f)
1117 1117 try:
1118 1118 st = os.lstat(p)
1119 1119 except:
1120 1120 self.ui.warn(_("%s does not exist!\n") % f)
1121 1121 rejected.append(f)
1122 1122 continue
1123 1123 if st.st_size > 10000000:
1124 1124 self.ui.warn(_("%s: up to %d MB of RAM may be required "
1125 1125 "to manage this file\n"
1126 1126 "(use 'hg revert %s' to cancel the "
1127 1127 "pending addition)\n")
1128 1128 % (f, 3 * st.st_size // 1000000, f))
1129 1129 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
1130 1130 self.ui.warn(_("%s not added: only files and symlinks "
1131 1131 "supported currently\n") % f)
1132 1132 rejected.append(p)
1133 1133 elif self.dirstate[f] in 'amn':
1134 1134 self.ui.warn(_("%s already tracked!\n") % f)
1135 1135 elif self.dirstate[f] == 'r':
1136 1136 self.dirstate.normallookup(f)
1137 1137 else:
1138 1138 self.dirstate.add(f)
1139 1139 return rejected
1140 1140 finally:
1141 1141 wlock.release()
1142 1142
1143 1143 def forget(self, list):
1144 1144 wlock = self.wlock()
1145 1145 try:
1146 1146 for f in list:
1147 1147 if self.dirstate[f] != 'a':
1148 1148 self.ui.warn(_("%s not added!\n") % f)
1149 1149 else:
1150 1150 self.dirstate.forget(f)
1151 1151 finally:
1152 1152 wlock.release()
1153 1153
1154 1154 def remove(self, list, unlink=False):
1155 1155 if unlink:
1156 1156 for f in list:
1157 1157 try:
1158 1158 util.unlink(self.wjoin(f))
1159 1159 except OSError, inst:
1160 1160 if inst.errno != errno.ENOENT:
1161 1161 raise
1162 1162 wlock = self.wlock()
1163 1163 try:
1164 1164 for f in list:
1165 1165 if unlink and os.path.exists(self.wjoin(f)):
1166 1166 self.ui.warn(_("%s still exists!\n") % f)
1167 1167 elif self.dirstate[f] == 'a':
1168 1168 self.dirstate.forget(f)
1169 1169 elif f not in self.dirstate:
1170 1170 self.ui.warn(_("%s not tracked!\n") % f)
1171 1171 else:
1172 1172 self.dirstate.remove(f)
1173 1173 finally:
1174 1174 wlock.release()
1175 1175
1176 1176 def undelete(self, list):
1177 1177 manifests = [self.manifest.read(self.changelog.read(p)[0])
1178 1178 for p in self.dirstate.parents() if p != nullid]
1179 1179 wlock = self.wlock()
1180 1180 try:
1181 1181 for f in list:
1182 1182 if self.dirstate[f] != 'r':
1183 1183 self.ui.warn(_("%s not removed!\n") % f)
1184 1184 else:
1185 1185 m = f in manifests[0] and manifests[0] or manifests[1]
1186 1186 t = self.file(f).read(m[f])
1187 1187 self.wwrite(f, t, m.flags(f))
1188 1188 self.dirstate.normal(f)
1189 1189 finally:
1190 1190 wlock.release()
1191 1191
1192 1192 def copy(self, source, dest):
1193 1193 p = self.wjoin(dest)
1194 1194 if not (os.path.exists(p) or os.path.islink(p)):
1195 1195 self.ui.warn(_("%s does not exist!\n") % dest)
1196 1196 elif not (os.path.isfile(p) or os.path.islink(p)):
1197 1197 self.ui.warn(_("copy failed: %s is not a file or a "
1198 1198 "symbolic link\n") % dest)
1199 1199 else:
1200 1200 wlock = self.wlock()
1201 1201 try:
1202 1202 if self.dirstate[dest] in '?r':
1203 1203 self.dirstate.add(dest)
1204 1204 self.dirstate.copy(source, dest)
1205 1205 finally:
1206 1206 wlock.release()
1207 1207
1208 1208 def heads(self, start=None):
1209 1209 heads = self.changelog.heads(start)
1210 1210 # sort the output in rev descending order
1211 1211 heads = [(-self.changelog.rev(h), h) for h in heads]
1212 1212 return [n for (r, n) in sorted(heads)]
1213 1213
1214 1214 def branchheads(self, branch=None, start=None, closed=False):
1215 1215 '''return a (possibly filtered) list of heads for the given branch
1216 1216
1217 1217 Heads are returned in topological order, from newest to oldest.
1218 1218 If branch is None, use the dirstate branch.
1219 1219 If start is not None, return only heads reachable from start.
1220 1220 If closed is True, return heads that are marked as closed as well.
1221 1221 '''
1222 1222 if branch is None:
1223 1223 branch = self[None].branch()
1224 1224 branches = self.branchmap()
1225 1225 if branch not in branches:
1226 1226 return []
1227 1227 # the cache returns heads ordered lowest to highest
1228 1228 bheads = list(reversed(branches[branch]))
1229 1229 if start is not None:
1230 1230 # filter out the heads that cannot be reached from startrev
1231 1231 fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
1232 1232 bheads = [h for h in bheads if h in fbheads]
1233 1233 if not closed:
1234 1234 bheads = [h for h in bheads if
1235 1235 ('close' not in self.changelog.read(h)[5])]
1236 1236 return bheads
1237 1237
1238 1238 def branches(self, nodes):
1239 1239 if not nodes:
1240 1240 nodes = [self.changelog.tip()]
1241 1241 b = []
1242 1242 for n in nodes:
1243 1243 t = n
1244 1244 while 1:
1245 1245 p = self.changelog.parents(n)
1246 1246 if p[1] != nullid or p[0] == nullid:
1247 1247 b.append((t, n, p[0], p[1]))
1248 1248 break
1249 1249 n = p[0]
1250 1250 return b
1251 1251
1252 1252 def between(self, pairs):
1253 1253 r = []
1254 1254
1255 1255 for top, bottom in pairs:
1256 1256 n, l, i = top, [], 0
1257 1257 f = 1
1258 1258
1259 1259 while n != bottom and n != nullid:
1260 1260 p = self.changelog.parents(n)[0]
1261 1261 if i == f:
1262 1262 l.append(n)
1263 1263 f = f * 2
1264 1264 n = p
1265 1265 i += 1
1266 1266
1267 1267 r.append(l)
1268 1268
1269 1269 return r
1270 1270
1271 1271 def findincoming(self, remote, base=None, heads=None, force=False):
1272 1272 """Return list of roots of the subsets of missing nodes from remote
1273 1273
1274 1274 If base dict is specified, assume that these nodes and their parents
1275 1275 exist on the remote side and that no child of a node of base exists
1276 1276 in both remote and self.
1277 1277 Furthermore base will be updated to include the nodes that exists
1278 1278 in self and remote but no children exists in self and remote.
1279 1279 If a list of heads is specified, return only nodes which are heads
1280 1280 or ancestors of these heads.
1281 1281
1282 1282 All the ancestors of base are in self and in remote.
1283 1283 All the descendants of the list returned are missing in self.
1284 1284 (and so we know that the rest of the nodes are missing in remote, see
1285 1285 outgoing)
1286 1286 """
1287 1287 return self.findcommonincoming(remote, base, heads, force)[1]
1288 1288
1289 1289 def findcommonincoming(self, remote, base=None, heads=None, force=False):
1290 1290 """Return a tuple (common, missing roots, heads) used to identify
1291 1291 missing nodes from remote.
1292 1292
1293 1293 If base dict is specified, assume that these nodes and their parents
1294 1294 exist on the remote side and that no child of a node of base exists
1295 1295 in both remote and self.
1296 1296 Furthermore base will be updated to include the nodes that exists
1297 1297 in self and remote but no children exists in self and remote.
1298 1298 If a list of heads is specified, return only nodes which are heads
1299 1299 or ancestors of these heads.
1300 1300
1301 1301 All the ancestors of base are in self and in remote.
1302 1302 """
1303 1303 m = self.changelog.nodemap
1304 1304 search = []
1305 1305 fetch = set()
1306 1306 seen = set()
1307 1307 seenbranch = set()
1308 1308 if base is None:
1309 1309 base = {}
1310 1310
1311 1311 if not heads:
1312 1312 heads = remote.heads()
1313 1313
1314 1314 if self.changelog.tip() == nullid:
1315 1315 base[nullid] = 1
1316 1316 if heads != [nullid]:
1317 1317 return [nullid], [nullid], list(heads)
1318 1318 return [nullid], [], []
1319 1319
1320 1320 # assume we're closer to the tip than the root
1321 1321 # and start by examining the heads
1322 1322 self.ui.status(_("searching for changes\n"))
1323 1323
1324 1324 unknown = []
1325 1325 for h in heads:
1326 1326 if h not in m:
1327 1327 unknown.append(h)
1328 1328 else:
1329 1329 base[h] = 1
1330 1330
1331 1331 heads = unknown
1332 1332 if not unknown:
1333 1333 return base.keys(), [], []
1334 1334
1335 1335 req = set(unknown)
1336 1336 reqcnt = 0
1337 1337
1338 1338 # search through remote branches
1339 1339 # a 'branch' here is a linear segment of history, with four parts:
1340 1340 # head, root, first parent, second parent
1341 1341 # (a branch always has two parents (or none) by definition)
1342 1342 unknown = remote.branches(unknown)
1343 1343 while unknown:
1344 1344 r = []
1345 1345 while unknown:
1346 1346 n = unknown.pop(0)
1347 1347 if n[0] in seen:
1348 1348 continue
1349 1349
1350 1350 self.ui.debug("examining %s:%s\n"
1351 1351 % (short(n[0]), short(n[1])))
1352 1352 if n[0] == nullid: # found the end of the branch
1353 1353 pass
1354 1354 elif n in seenbranch:
1355 1355 self.ui.debug("branch already found\n")
1356 1356 continue
1357 1357 elif n[1] and n[1] in m: # do we know the base?
1358 1358 self.ui.debug("found incomplete branch %s:%s\n"
1359 1359 % (short(n[0]), short(n[1])))
1360 1360 search.append(n[0:2]) # schedule branch range for scanning
1361 1361 seenbranch.add(n)
1362 1362 else:
1363 1363 if n[1] not in seen and n[1] not in fetch:
1364 1364 if n[2] in m and n[3] in m:
1365 1365 self.ui.debug("found new changeset %s\n" %
1366 1366 short(n[1]))
1367 1367 fetch.add(n[1]) # earliest unknown
1368 1368 for p in n[2:4]:
1369 1369 if p in m:
1370 1370 base[p] = 1 # latest known
1371 1371
1372 1372 for p in n[2:4]:
1373 1373 if p not in req and p not in m:
1374 1374 r.append(p)
1375 1375 req.add(p)
1376 1376 seen.add(n[0])
1377 1377
1378 1378 if r:
1379 1379 reqcnt += 1
1380 1380 self.ui.progress(_('searching'), reqcnt, unit=_('queries'))
1381 1381 self.ui.debug("request %d: %s\n" %
1382 1382 (reqcnt, " ".join(map(short, r))))
1383 1383 for p in xrange(0, len(r), 10):
1384 1384 for b in remote.branches(r[p:p + 10]):
1385 1385 self.ui.debug("received %s:%s\n" %
1386 1386 (short(b[0]), short(b[1])))
1387 1387 unknown.append(b)
1388 1388
1389 1389 # do binary search on the branches we found
1390 1390 while search:
1391 1391 newsearch = []
1392 1392 reqcnt += 1
1393 1393 self.ui.progress(_('searching'), reqcnt, unit=_('queries'))
1394 1394 for n, l in zip(search, remote.between(search)):
1395 1395 l.append(n[1])
1396 1396 p = n[0]
1397 1397 f = 1
1398 1398 for i in l:
1399 1399 self.ui.debug("narrowing %d:%d %s\n" % (f, len(l), short(i)))
1400 1400 if i in m:
1401 1401 if f <= 2:
1402 1402 self.ui.debug("found new branch changeset %s\n" %
1403 1403 short(p))
1404 1404 fetch.add(p)
1405 1405 base[i] = 1
1406 1406 else:
1407 1407 self.ui.debug("narrowed branch search to %s:%s\n"
1408 1408 % (short(p), short(i)))
1409 1409 newsearch.append((p, i))
1410 1410 break
1411 1411 p, f = i, f * 2
1412 1412 search = newsearch
1413 1413
1414 1414 # sanity check our fetch list
1415 1415 for f in fetch:
1416 1416 if f in m:
1417 1417 raise error.RepoError(_("already have changeset ")
1418 1418 + short(f[:4]))
1419 1419
1420 1420 if base.keys() == [nullid]:
1421 1421 if force:
1422 1422 self.ui.warn(_("warning: repository is unrelated\n"))
1423 1423 else:
1424 1424 raise util.Abort(_("repository is unrelated"))
1425 1425
1426 1426 self.ui.debug("found new changesets starting at " +
1427 1427 " ".join([short(f) for f in fetch]) + "\n")
1428 1428
1429 1429 self.ui.progress(_('searching'), None)
1430 1430 self.ui.debug("%d total queries\n" % reqcnt)
1431 1431
1432 1432 return base.keys(), list(fetch), heads
1433 1433
1434 1434 def findoutgoing(self, remote, base=None, heads=None, force=False):
1435 1435 """Return list of nodes that are roots of subsets not in remote
1436 1436
1437 1437 If base dict is specified, assume that these nodes and their parents
1438 1438 exist on the remote side.
1439 1439 If a list of heads is specified, return only nodes which are heads
1440 1440 or ancestors of these heads, and return a second element which
1441 1441 contains all remote heads which get new children.
1442 1442 """
1443 1443 if base is None:
1444 1444 base = {}
1445 1445 self.findincoming(remote, base, heads, force=force)
1446 1446
1447 1447 self.ui.debug("common changesets up to "
1448 1448 + " ".join(map(short, base.keys())) + "\n")
1449 1449
1450 1450 remain = set(self.changelog.nodemap)
1451 1451
1452 1452 # prune everything remote has from the tree
1453 1453 remain.remove(nullid)
1454 1454 remove = base.keys()
1455 1455 while remove:
1456 1456 n = remove.pop(0)
1457 1457 if n in remain:
1458 1458 remain.remove(n)
1459 1459 for p in self.changelog.parents(n):
1460 1460 remove.append(p)
1461 1461
1462 1462 # find every node whose parents have been pruned
1463 1463 subset = []
1464 1464 # find every remote head that will get new children
1465 1465 updated_heads = set()
1466 1466 for n in remain:
1467 1467 p1, p2 = self.changelog.parents(n)
1468 1468 if p1 not in remain and p2 not in remain:
1469 1469 subset.append(n)
1470 1470 if heads:
1471 1471 if p1 in heads:
1472 1472 updated_heads.add(p1)
1473 1473 if p2 in heads:
1474 1474 updated_heads.add(p2)
1475 1475
1476 1476 # this is the set of all roots we have to push
1477 1477 if heads:
1478 1478 return subset, list(updated_heads)
1479 1479 else:
1480 1480 return subset
1481 1481
1482 1482 def pull(self, remote, heads=None, force=False):
1483 1483 lock = self.lock()
1484 1484 try:
1485 1485 common, fetch, rheads = self.findcommonincoming(remote, heads=heads,
1486 1486 force=force)
1487 1487 if not fetch:
1488 1488 self.ui.status(_("no changes found\n"))
1489 1489 return 0
1490 1490
1491 1491 if fetch == [nullid]:
1492 1492 self.ui.status(_("requesting all changes\n"))
1493 1493 elif heads is None and remote.capable('changegroupsubset'):
1494 1494 # issue1320, avoid a race if remote changed after discovery
1495 1495 heads = rheads
1496 1496
1497 1497 if heads is None:
1498 1498 cg = remote.changegroup(fetch, 'pull')
1499 1499 else:
1500 1500 if not remote.capable('changegroupsubset'):
1501 1501 raise util.Abort(_("Partial pull cannot be done because "
1502 1502 "other repository doesn't support "
1503 1503 "changegroupsubset."))
1504 1504 cg = remote.changegroupsubset(fetch, heads, 'pull')
1505 1505 return self.addchangegroup(cg, 'pull', remote.url())
1506 1506 finally:
1507 1507 lock.release()
1508 1508
1509 1509 def push(self, remote, force=False, revs=None):
1510 1510 '''Push outgoing changesets (limited by revs) from the current
1511 1511 repository to remote. Return an integer:
1512 1512 - 0 means HTTP error *or* nothing to push
1513 1513 - 1 means we pushed and remote head count is unchanged *or*
1514 1514 we have outgoing changesets but refused to push
1515 1515 - other values as described by addchangegroup()
1516 1516 '''
1517 1517 # there are two ways to push to remote repo:
1518 1518 #
1519 1519 # addchangegroup assumes local user can lock remote
1520 1520 # repo (local filesystem, old ssh servers).
1521 1521 #
1522 1522 # unbundle assumes local user cannot lock remote repo (new ssh
1523 1523 # servers, http servers).
1524 1524
1525 1525 if remote.capable('unbundle'):
1526 1526 return self.push_unbundle(remote, force, revs)
1527 1527 return self.push_addchangegroup(remote, force, revs)
1528 1528
1529 1529 def prepush(self, remote, force, revs):
1530 1530 '''Analyze the local and remote repositories and determine which
1531 1531 changesets need to be pushed to the remote. Return value depends
1532 1532 on circumstances:
1533 1533
1534 1534 If we are not going to push anything, return a tuple (None,
1535 1535 outgoing) where outgoing is 0 if there are no outgoing
1536 1536 changesets and 1 if there are, but we refuse to push them
1537 1537 (e.g. would create new remote heads).
1538 1538
1539 1539 Otherwise, return a tuple (changegroup, remoteheads), where
1540 1540 changegroup is a readable file-like object whose read() returns
1541 1541 successive changegroup chunks ready to be sent over the wire and
1542 1542 remoteheads is the list of remote heads.'''
1543 1543 common = {}
1544 1544 remote_heads = remote.heads()
1545 1545 inc = self.findincoming(remote, common, remote_heads, force=force)
1546 1546
1547 1547 cl = self.changelog
1548 1548 update, updated_heads = self.findoutgoing(remote, common, remote_heads)
1549 1549 outg, bases, heads = cl.nodesbetween(update, revs)
1550 1550
1551 1551 if not bases:
1552 1552 self.ui.status(_("no changes found\n"))
1553 1553 return None, 1
1554 1554
1555 1555 if not force and remote_heads != [nullid]:
1556 1556
1557 1557 def fail_multiple_heads(unsynced, branch=None):
1558 1558 if branch:
1559 1559 msg = _("abort: push creates new remote heads"
1560 1560 " on branch '%s'!\n") % branch
1561 1561 else:
1562 1562 msg = _("abort: push creates new remote heads!\n")
1563 1563 self.ui.warn(msg)
1564 1564 if unsynced:
1565 1565 self.ui.status(_("(you should pull and merge or"
1566 1566 " use push -f to force)\n"))
1567 1567 else:
1568 1568 self.ui.status(_("(did you forget to merge?"
1569 1569 " use push -f to force)\n"))
1570 1570 return None, 0
1571 1571
1572 1572 if remote.capable('branchmap'):
1573 1573 # Check for each named branch if we're creating new remote heads.
1574 1574 # To be a remote head after push, node must be either:
1575 1575 # - unknown locally
1576 1576 # - a local outgoing head descended from update
1577 1577 # - a remote head that's known locally and not
1578 1578 # ancestral to an outgoing head
1579 1579 #
1580 1580 # New named branches cannot be created without --force.
1581 1581
1582 1582 # 1. Create set of branches involved in the push.
1583 1583 branches = set(self[n].branch() for n in outg)
1584 1584
1585 1585 # 2. Check for new branches on the remote.
1586 1586 remotemap = remote.branchmap()
1587 1587 newbranches = branches - set(remotemap)
1588 1588 if newbranches: # new branch requires --force
1589 1589 branchnames = ', '.join("%s" % b for b in newbranches)
1590 1590 self.ui.warn(_("abort: push creates "
1591 1591 "new remote branches: %s!\n")
1592 1592 % branchnames)
1593 1593 self.ui.status(_("(use 'hg push -f' to force)\n"))
1594 1594 return None, 0
1595 1595
1596 1596 # 3. Construct the initial oldmap and newmap dicts.
1597 1597 # They contain information about the remote heads before and
1598 1598 # after the push, respectively.
1599 1599 # Heads not found locally are not included in either dict,
1600 1600 # since they won't be affected by the push.
1601 1601 # unsynced contains all branches with incoming changesets.
1602 1602 oldmap = {}
1603 1603 newmap = {}
1604 1604 unsynced = set()
1605 1605 for branch in branches:
1606 1606 remoteheads = remotemap[branch]
1607 1607 prunedheads = [h for h in remoteheads if h in cl.nodemap]
1608 1608 oldmap[branch] = prunedheads
1609 1609 newmap[branch] = list(prunedheads)
1610 1610 if len(remoteheads) > len(prunedheads):
1611 1611 unsynced.add(branch)
1612 1612
1613 1613 # 4. Update newmap with outgoing changes.
1614 1614 # This will possibly add new heads and remove existing ones.
1615 1615 ctxgen = (self[n] for n in outg)
1616 1616 self._updatebranchcache(newmap, ctxgen)
1617 1617
1618 1618 # 5. Check for new heads.
1619 1619 # If there are more heads after the push than before, a suitable
1620 1620 # warning, depending on unsynced status, is displayed.
1621 1621 for branch in branches:
1622 1622 if len(newmap[branch]) > len(oldmap[branch]):
1623 1623 return fail_multiple_heads(branch in unsynced, branch)
1624 1624
1625 1625 # 6. Check for unsynced changes on involved branches.
1626 1626 if unsynced:
1627 1627 self.ui.warn(_("note: unsynced remote changes!\n"))
1628 1628
1629 1629 else:
1630 1630 # Old servers: Check for new topological heads.
1631 1631 # Code based on _updatebranchcache.
1632 1632 newheads = set(h for h in remote_heads if h in cl.nodemap)
1633 1633 oldheadcnt = len(newheads)
1634 1634 newheads.update(outg)
1635 1635 if len(newheads) > 1:
1636 1636 for latest in reversed(outg):
1637 1637 if latest not in newheads:
1638 1638 continue
1639 1639 minhrev = min(cl.rev(h) for h in newheads)
1640 1640 reachable = cl.reachable(latest, cl.node(minhrev))
1641 1641 reachable.remove(latest)
1642 1642 newheads.difference_update(reachable)
1643 1643 if len(newheads) > oldheadcnt:
1644 1644 return fail_multiple_heads(inc)
1645 1645 if inc:
1646 1646 self.ui.warn(_("note: unsynced remote changes!\n"))
1647 1647
1648 1648 if revs is None:
1649 1649 # use the fast path, no race possible on push
1650 1650 nodes = self.changelog.findmissing(common.keys())
1651 1651 cg = self._changegroup(nodes, 'push')
1652 1652 else:
1653 1653 cg = self.changegroupsubset(update, revs, 'push')
1654 1654 return cg, remote_heads
1655 1655
1656 1656 def push_addchangegroup(self, remote, force, revs):
1657 1657 '''Push a changegroup by locking the remote and sending the
1658 1658 addchangegroup command to it. Used for local and old SSH repos.
1659 1659 Return an integer: see push().
1660 1660 '''
1661 1661 lock = remote.lock()
1662 1662 try:
1663 1663 ret = self.prepush(remote, force, revs)
1664 1664 if ret[0] is not None:
1665 1665 cg, remote_heads = ret
1666 1666 # here, we return an integer indicating remote head count change
1667 1667 return remote.addchangegroup(cg, 'push', self.url())
1668 1668 # and here we return 0 for "nothing to push" or 1 for
1669 1669 # "something to push but I refuse"
1670 1670 return ret[1]
1671 1671 finally:
1672 1672 lock.release()
1673 1673
1674 1674 def push_unbundle(self, remote, force, revs):
1675 1675 '''Push a changegroup by unbundling it on the remote. Used for new
1676 1676 SSH and HTTP repos. Return an integer: see push().'''
1677 1677 # local repo finds heads on server, finds out what revs it
1678 1678 # must push. once revs transferred, if server finds it has
1679 1679 # different heads (someone else won commit/push race), server
1680 1680 # aborts.
1681 1681
1682 1682 ret = self.prepush(remote, force, revs)
1683 1683 if ret[0] is not None:
1684 1684 cg, remote_heads = ret
1685 1685 if force:
1686 1686 remote_heads = ['force']
1687 1687 # ssh: return remote's addchangegroup()
1688 1688 # http: return remote's addchangegroup() or 0 for error
1689 1689 return remote.unbundle(cg, remote_heads, 'push')
1690 1690 # as in push_addchangegroup()
1691 1691 return ret[1]
1692 1692
1693 1693 def changegroupinfo(self, nodes, source):
1694 1694 if self.ui.verbose or source == 'bundle':
1695 1695 self.ui.status(_("%d changesets found\n") % len(nodes))
1696 1696 if self.ui.debugflag:
1697 1697 self.ui.debug("list of changesets:\n")
1698 1698 for node in nodes:
1699 1699 self.ui.debug("%s\n" % hex(node))
1700 1700
1701 1701 def changegroupsubset(self, bases, heads, source, extranodes=None):
1702 1702 """Compute a changegroup consisting of all the nodes that are
1703 1703 descendents of any of the bases and ancestors of any of the heads.
1704 1704 Return a chunkbuffer object whose read() method will return
1705 1705 successive changegroup chunks.
1706 1706
1707 1707 It is fairly complex as determining which filenodes and which
1708 1708 manifest nodes need to be included for the changeset to be complete
1709 1709 is non-trivial.
1710 1710
1711 1711 Another wrinkle is doing the reverse, figuring out which changeset in
1712 1712 the changegroup a particular filenode or manifestnode belongs to.
1713 1713
1714 1714 The caller can specify some nodes that must be included in the
1715 1715 changegroup using the extranodes argument. It should be a dict
1716 1716 where the keys are the filenames (or 1 for the manifest), and the
1717 1717 values are lists of (node, linknode) tuples, where node is a wanted
1718 1718 node and linknode is the changelog node that should be transmitted as
1719 1719 the linkrev.
1720 1720 """
1721 1721
1722 1722 # Set up some initial variables
1723 1723 # Make it easy to refer to self.changelog
1724 1724 cl = self.changelog
1725 1725 # msng is short for missing - compute the list of changesets in this
1726 1726 # changegroup.
1727 1727 if not bases:
1728 1728 bases = [nullid]
1729 1729 msng_cl_lst, bases, heads = cl.nodesbetween(bases, heads)
1730 1730
1731 1731 if extranodes is None:
1732 1732 # can we go through the fast path ?
1733 1733 heads.sort()
1734 1734 allheads = self.heads()
1735 1735 allheads.sort()
1736 1736 if heads == allheads:
1737 1737 return self._changegroup(msng_cl_lst, source)
1738 1738
1739 1739 # slow path
1740 1740 self.hook('preoutgoing', throw=True, source=source)
1741 1741
1742 1742 self.changegroupinfo(msng_cl_lst, source)
1743 1743 # Some bases may turn out to be superfluous, and some heads may be
1744 1744 # too. nodesbetween will return the minimal set of bases and heads
1745 1745 # necessary to re-create the changegroup.
1746 1746
1747 1747 # Known heads are the list of heads that it is assumed the recipient
1748 1748 # of this changegroup will know about.
1749 1749 knownheads = set()
1750 1750 # We assume that all parents of bases are known heads.
1751 1751 for n in bases:
1752 1752 knownheads.update(cl.parents(n))
1753 1753 knownheads.discard(nullid)
1754 1754 knownheads = list(knownheads)
1755 1755 if knownheads:
1756 1756 # Now that we know what heads are known, we can compute which
1757 1757 # changesets are known. The recipient must know about all
1758 1758 # changesets required to reach the known heads from the null
1759 1759 # changeset.
1760 1760 has_cl_set, junk, junk = cl.nodesbetween(None, knownheads)
1761 1761 junk = None
1762 1762 # Transform the list into a set.
1763 1763 has_cl_set = set(has_cl_set)
1764 1764 else:
1765 1765 # If there were no known heads, the recipient cannot be assumed to
1766 1766 # know about any changesets.
1767 1767 has_cl_set = set()
1768 1768
1769 1769 # Make it easy to refer to self.manifest
1770 1770 mnfst = self.manifest
1771 1771 # We don't know which manifests are missing yet
1772 1772 msng_mnfst_set = {}
1773 1773 # Nor do we know which filenodes are missing.
1774 1774 msng_filenode_set = {}
1775 1775
1776 1776 junk = mnfst.index[len(mnfst) - 1] # Get around a bug in lazyindex
1777 1777 junk = None
1778 1778
1779 1779 # A changeset always belongs to itself, so the changenode lookup
1780 1780 # function for a changenode is identity.
1781 1781 def identity(x):
1782 1782 return x
1783 1783
1784 1784 # If we determine that a particular file or manifest node must be a
1785 1785 # node that the recipient of the changegroup will already have, we can
1786 1786 # also assume the recipient will have all the parents. This function
1787 1787 # prunes them from the set of missing nodes.
1788 1788 def prune_parents(revlog, hasset, msngset):
1789 1789 for r in revlog.ancestors(*[revlog.rev(n) for n in hasset]):
1790 1790 msngset.pop(revlog.node(r), None)
1791 1791
1792 1792 # Use the information collected in collect_manifests_and_files to say
1793 1793 # which changenode any manifestnode belongs to.
1794 1794 def lookup_manifest_link(mnfstnode):
1795 1795 return msng_mnfst_set[mnfstnode]
1796 1796
1797 1797 # A function generating function that sets up the initial environment
1798 1798 # the inner function.
1799 1799 def filenode_collector(changedfiles):
1800 1800 # This gathers information from each manifestnode included in the
1801 1801 # changegroup about which filenodes the manifest node references
1802 1802 # so we can include those in the changegroup too.
1803 1803 #
1804 1804 # It also remembers which changenode each filenode belongs to. It
1805 1805 # does this by assuming the a filenode belongs to the changenode
1806 1806 # the first manifest that references it belongs to.
1807 1807 def collect_msng_filenodes(mnfstnode):
1808 1808 r = mnfst.rev(mnfstnode)
1809 1809 if r - 1 in mnfst.parentrevs(r):
1810 1810 # If the previous rev is one of the parents,
1811 1811 # we only need to see a diff.
1812 1812 deltamf = mnfst.readdelta(mnfstnode)
1813 1813 # For each line in the delta
1814 1814 for f, fnode in deltamf.iteritems():
1815 1815 f = changedfiles.get(f, None)
1816 1816 # And if the file is in the list of files we care
1817 1817 # about.
1818 1818 if f is not None:
1819 1819 # Get the changenode this manifest belongs to
1820 1820 clnode = msng_mnfst_set[mnfstnode]
1821 1821 # Create the set of filenodes for the file if
1822 1822 # there isn't one already.
1823 1823 ndset = msng_filenode_set.setdefault(f, {})
1824 1824 # And set the filenode's changelog node to the
1825 1825 # manifest's if it hasn't been set already.
1826 1826 ndset.setdefault(fnode, clnode)
1827 1827 else:
1828 1828 # Otherwise we need a full manifest.
1829 1829 m = mnfst.read(mnfstnode)
1830 1830 # For every file in we care about.
1831 1831 for f in changedfiles:
1832 1832 fnode = m.get(f, None)
1833 1833 # If it's in the manifest
1834 1834 if fnode is not None:
1835 1835 # See comments above.
1836 1836 clnode = msng_mnfst_set[mnfstnode]
1837 1837 ndset = msng_filenode_set.setdefault(f, {})
1838 1838 ndset.setdefault(fnode, clnode)
1839 1839 return collect_msng_filenodes
1840 1840
1841 1841 # We have a list of filenodes we think we need for a file, lets remove
1842 1842 # all those we know the recipient must have.
1843 1843 def prune_filenodes(f, filerevlog):
1844 1844 msngset = msng_filenode_set[f]
1845 1845 hasset = set()
1846 1846 # If a 'missing' filenode thinks it belongs to a changenode we
1847 1847 # assume the recipient must have, then the recipient must have
1848 1848 # that filenode.
1849 1849 for n in msngset:
1850 1850 clnode = cl.node(filerevlog.linkrev(filerevlog.rev(n)))
1851 1851 if clnode in has_cl_set:
1852 1852 hasset.add(n)
1853 1853 prune_parents(filerevlog, hasset, msngset)
1854 1854
1855 1855 # A function generator function that sets up the a context for the
1856 1856 # inner function.
1857 1857 def lookup_filenode_link_func(fname):
1858 1858 msngset = msng_filenode_set[fname]
1859 1859 # Lookup the changenode the filenode belongs to.
1860 1860 def lookup_filenode_link(fnode):
1861 1861 return msngset[fnode]
1862 1862 return lookup_filenode_link
1863 1863
1864 1864 # Add the nodes that were explicitly requested.
1865 1865 def add_extra_nodes(name, nodes):
1866 1866 if not extranodes or name not in extranodes:
1867 1867 return
1868 1868
1869 1869 for node, linknode in extranodes[name]:
1870 1870 if node not in nodes:
1871 1871 nodes[node] = linknode
1872 1872
1873 1873 # Now that we have all theses utility functions to help out and
1874 1874 # logically divide up the task, generate the group.
1875 1875 def gengroup():
1876 1876 # The set of changed files starts empty.
1877 1877 changedfiles = {}
1878 1878 collect = changegroup.collector(cl, msng_mnfst_set, changedfiles)
1879 1879
1880 1880 # Create a changenode group generator that will call our functions
1881 1881 # back to lookup the owning changenode and collect information.
1882 1882 group = cl.group(msng_cl_lst, identity, collect)
1883 1883 cnt = 0
1884 1884 for chnk in group:
1885 1885 yield chnk
1886 1886 self.ui.progress(_('bundling changes'), cnt, unit=_('chunks'))
1887 1887 cnt += 1
1888 1888 self.ui.progress(_('bundling changes'), None)
1889 1889
1890 1890
1891 1891 # Figure out which manifest nodes (of the ones we think might be
1892 1892 # part of the changegroup) the recipient must know about and
1893 1893 # remove them from the changegroup.
1894 1894 has_mnfst_set = set()
1895 1895 for n in msng_mnfst_set:
1896 1896 # If a 'missing' manifest thinks it belongs to a changenode
1897 1897 # the recipient is assumed to have, obviously the recipient
1898 1898 # must have that manifest.
1899 1899 linknode = cl.node(mnfst.linkrev(mnfst.rev(n)))
1900 1900 if linknode in has_cl_set:
1901 1901 has_mnfst_set.add(n)
1902 1902 prune_parents(mnfst, has_mnfst_set, msng_mnfst_set)
1903 1903 add_extra_nodes(1, msng_mnfst_set)
1904 1904 msng_mnfst_lst = msng_mnfst_set.keys()
1905 1905 # Sort the manifestnodes by revision number.
1906 1906 msng_mnfst_lst.sort(key=mnfst.rev)
1907 1907 # Create a generator for the manifestnodes that calls our lookup
1908 1908 # and data collection functions back.
1909 1909 group = mnfst.group(msng_mnfst_lst, lookup_manifest_link,
1910 1910 filenode_collector(changedfiles))
1911 1911 cnt = 0
1912 1912 for chnk in group:
1913 1913 yield chnk
1914 1914 self.ui.progress(_('bundling manifests'), cnt, unit=_('chunks'))
1915 1915 cnt += 1
1916 1916 self.ui.progress(_('bundling manifests'), None)
1917 1917
1918 1918 # These are no longer needed, dereference and toss the memory for
1919 1919 # them.
1920 1920 msng_mnfst_lst = None
1921 1921 msng_mnfst_set.clear()
1922 1922
1923 1923 if extranodes:
1924 1924 for fname in extranodes:
1925 1925 if isinstance(fname, int):
1926 1926 continue
1927 1927 msng_filenode_set.setdefault(fname, {})
1928 1928 changedfiles[fname] = 1
1929 1929 # Go through all our files in order sorted by name.
1930 1930 cnt = 0
1931 1931 for fname in sorted(changedfiles):
1932 1932 filerevlog = self.file(fname)
1933 1933 if not len(filerevlog):
1934 1934 raise util.Abort(_("empty or missing revlog for %s") % fname)
1935 1935 # Toss out the filenodes that the recipient isn't really
1936 1936 # missing.
1937 1937 if fname in msng_filenode_set:
1938 1938 prune_filenodes(fname, filerevlog)
1939 1939 add_extra_nodes(fname, msng_filenode_set[fname])
1940 1940 msng_filenode_lst = msng_filenode_set[fname].keys()
1941 1941 else:
1942 1942 msng_filenode_lst = []
1943 1943 # If any filenodes are left, generate the group for them,
1944 1944 # otherwise don't bother.
1945 1945 if len(msng_filenode_lst) > 0:
1946 1946 yield changegroup.chunkheader(len(fname))
1947 1947 yield fname
1948 1948 # Sort the filenodes by their revision #
1949 1949 msng_filenode_lst.sort(key=filerevlog.rev)
1950 1950 # Create a group generator and only pass in a changenode
1951 1951 # lookup function as we need to collect no information
1952 1952 # from filenodes.
1953 1953 group = filerevlog.group(msng_filenode_lst,
1954 1954 lookup_filenode_link_func(fname))
1955 1955 for chnk in group:
1956 1956 self.ui.progress(
1957 1957 _('bundling files'), cnt, item=fname, unit=_('chunks'))
1958 1958 cnt += 1
1959 1959 yield chnk
1960 1960 if fname in msng_filenode_set:
1961 1961 # Don't need this anymore, toss it to free memory.
1962 1962 del msng_filenode_set[fname]
1963 1963 # Signal that no more groups are left.
1964 1964 yield changegroup.closechunk()
1965 1965 self.ui.progress(_('bundling files'), None)
1966 1966
1967 1967 if msng_cl_lst:
1968 1968 self.hook('outgoing', node=hex(msng_cl_lst[0]), source=source)
1969 1969
1970 1970 return util.chunkbuffer(gengroup())
1971 1971
1972 1972 def changegroup(self, basenodes, source):
1973 1973 # to avoid a race we use changegroupsubset() (issue1320)
1974 1974 return self.changegroupsubset(basenodes, self.heads(), source)
1975 1975
1976 1976 def _changegroup(self, nodes, source):
1977 1977 """Compute the changegroup of all nodes that we have that a recipient
1978 1978 doesn't. Return a chunkbuffer object whose read() method will return
1979 1979 successive changegroup chunks.
1980 1980
1981 1981 This is much easier than the previous function as we can assume that
1982 1982 the recipient has any changenode we aren't sending them.
1983 1983
1984 1984 nodes is the set of nodes to send"""
1985 1985
1986 1986 self.hook('preoutgoing', throw=True, source=source)
1987 1987
1988 1988 cl = self.changelog
1989 1989 revset = set([cl.rev(n) for n in nodes])
1990 1990 self.changegroupinfo(nodes, source)
1991 1991
1992 1992 def identity(x):
1993 1993 return x
1994 1994
1995 1995 def gennodelst(log):
1996 1996 for r in log:
1997 1997 if log.linkrev(r) in revset:
1998 1998 yield log.node(r)
1999 1999
2000 2000 def lookuprevlink_func(revlog):
2001 2001 def lookuprevlink(n):
2002 2002 return cl.node(revlog.linkrev(revlog.rev(n)))
2003 2003 return lookuprevlink
2004 2004
2005 2005 def gengroup():
2006 2006 '''yield a sequence of changegroup chunks (strings)'''
2007 2007 # construct a list of all changed files
2008 2008 changedfiles = {}
2009 2009 mmfs = {}
2010 2010 collect = changegroup.collector(cl, mmfs, changedfiles)
2011 2011
2012 2012 cnt = 0
2013 2013 for chnk in cl.group(nodes, identity, collect):
2014 2014 self.ui.progress(_('bundling changes'), cnt, unit=_('chunks'))
2015 2015 cnt += 1
2016 2016 yield chnk
2017 2017 self.ui.progress(_('bundling changes'), None)
2018 2018
2019 2019 mnfst = self.manifest
2020 2020 nodeiter = gennodelst(mnfst)
2021 2021 cnt = 0
2022 2022 for chnk in mnfst.group(nodeiter, lookuprevlink_func(mnfst)):
2023 2023 self.ui.progress(_('bundling manifests'), cnt, unit=_('chunks'))
2024 2024 cnt += 1
2025 2025 yield chnk
2026 2026 self.ui.progress(_('bundling manifests'), None)
2027 2027
2028 2028 cnt = 0
2029 2029 for fname in sorted(changedfiles):
2030 2030 filerevlog = self.file(fname)
2031 2031 if not len(filerevlog):
2032 2032 raise util.Abort(_("empty or missing revlog for %s") % fname)
2033 2033 nodeiter = gennodelst(filerevlog)
2034 2034 nodeiter = list(nodeiter)
2035 2035 if nodeiter:
2036 2036 yield changegroup.chunkheader(len(fname))
2037 2037 yield fname
2038 2038 lookup = lookuprevlink_func(filerevlog)
2039 2039 for chnk in filerevlog.group(nodeiter, lookup):
2040 2040 self.ui.progress(
2041 2041 _('bundling files'), cnt, item=fname, unit=_('chunks'))
2042 2042 cnt += 1
2043 2043 yield chnk
2044 2044 self.ui.progress(_('bundling files'), None)
2045 2045
2046 2046 yield changegroup.closechunk()
2047 2047
2048 2048 if nodes:
2049 2049 self.hook('outgoing', node=hex(nodes[0]), source=source)
2050 2050
2051 2051 return util.chunkbuffer(gengroup())
2052 2052
2053 2053 def addchangegroup(self, source, srctype, url, emptyok=False):
2054 2054 """Add the changegroup returned by source.read() to this repo.
2055 2055 srctype is a string like 'push', 'pull', or 'unbundle'. url is
2056 2056 the URL of the repo where this changegroup is coming from.
2057 2057
2058 2058 Return an integer summarizing the change to this repo:
2059 2059 - nothing changed or no source: 0
2060 2060 - more heads than before: 1+added heads (2..n)
2061 2061 - fewer heads than before: -1-removed heads (-2..-n)
2062 2062 - number of heads stays the same: 1
2063 2063 """
2064 2064 def csmap(x):
2065 2065 self.ui.debug("add changeset %s\n" % short(x))
2066 2066 return len(cl)
2067 2067
2068 2068 def revmap(x):
2069 2069 return cl.rev(x)
2070 2070
2071 2071 if not source:
2072 2072 return 0
2073 2073
2074 2074 self.hook('prechangegroup', throw=True, source=srctype, url=url)
2075 2075
2076 2076 changesets = files = revisions = 0
2077 2077 efiles = set()
2078 2078
2079 2079 # write changelog data to temp files so concurrent readers will not see
2080 2080 # inconsistent view
2081 2081 cl = self.changelog
2082 2082 cl.delayupdate()
2083 2083 oldheads = len(cl.heads())
2084 2084
2085 2085 tr = self.transaction("\n".join([srctype, urlmod.hidepassword(url)]))
2086 2086 try:
2087 2087 trp = weakref.proxy(tr)
2088 2088 # pull off the changeset group
2089 2089 self.ui.status(_("adding changesets\n"))
2090 2090 clstart = len(cl)
2091 2091 class prog(object):
2092 2092 step = _('changesets')
2093 2093 count = 1
2094 2094 ui = self.ui
2095 2095 total = None
2096 2096 def __call__(self):
2097 2097 self.ui.progress(self.step, self.count, unit=_('chunks'),
2098 2098 total=self.total)
2099 2099 self.count += 1
2100 2100 pr = prog()
2101 2101 chunkiter = changegroup.chunkiter(source, progress=pr)
2102 2102 if cl.addgroup(chunkiter, csmap, trp) is None and not emptyok:
2103 2103 raise util.Abort(_("received changelog group is empty"))
2104 2104 clend = len(cl)
2105 2105 changesets = clend - clstart
2106 2106 for c in xrange(clstart, clend):
2107 2107 efiles.update(self[c].files())
2108 2108 efiles = len(efiles)
2109 2109 self.ui.progress(_('changesets'), None)
2110 2110
2111 2111 # pull off the manifest group
2112 2112 self.ui.status(_("adding manifests\n"))
2113 2113 pr.step = _('manifests')
2114 2114 pr.count = 1
2115 2115 pr.total = changesets # manifests <= changesets
2116 2116 chunkiter = changegroup.chunkiter(source, progress=pr)
2117 2117 # no need to check for empty manifest group here:
2118 2118 # if the result of the merge of 1 and 2 is the same in 3 and 4,
2119 2119 # no new manifest will be created and the manifest group will
2120 2120 # be empty during the pull
2121 2121 self.manifest.addgroup(chunkiter, revmap, trp)
2122 2122 self.ui.progress(_('manifests'), None)
2123 2123
2124 2124 needfiles = {}
2125 2125 if self.ui.configbool('server', 'validate', default=False):
2126 2126 # validate incoming csets have their manifests
2127 2127 for cset in xrange(clstart, clend):
2128 2128 mfest = self.changelog.read(self.changelog.node(cset))[0]
2129 2129 mfest = self.manifest.readdelta(mfest)
2130 2130 # store file nodes we must see
2131 2131 for f, n in mfest.iteritems():
2132 2132 needfiles.setdefault(f, set()).add(n)
2133 2133
2134 2134 # process the files
2135 2135 self.ui.status(_("adding file changes\n"))
2136 2136 pr.step = 'files'
2137 2137 pr.count = 1
2138 2138 pr.total = efiles
2139 2139 while 1:
2140 2140 f = changegroup.getchunk(source)
2141 2141 if not f:
2142 2142 break
2143 2143 self.ui.debug("adding %s revisions\n" % f)
2144 2144 pr()
2145 2145 fl = self.file(f)
2146 2146 o = len(fl)
2147 2147 chunkiter = changegroup.chunkiter(source)
2148 2148 if fl.addgroup(chunkiter, revmap, trp) is None:
2149 2149 raise util.Abort(_("received file revlog group is empty"))
2150 2150 revisions += len(fl) - o
2151 2151 files += 1
2152 2152 if f in needfiles:
2153 2153 needs = needfiles[f]
2154 2154 for new in xrange(o, len(fl)):
2155 2155 n = fl.node(new)
2156 2156 if n in needs:
2157 2157 needs.remove(n)
2158 2158 if not needs:
2159 2159 del needfiles[f]
2160 2160 self.ui.progress(_('files'), None)
2161 2161
2162 2162 for f, needs in needfiles.iteritems():
2163 2163 fl = self.file(f)
2164 2164 for n in needs:
2165 2165 try:
2166 2166 fl.rev(n)
2167 2167 except error.LookupError:
2168 2168 raise util.Abort(
2169 2169 _('missing file data for %s:%s - run hg verify') %
2170 2170 (f, hex(n)))
2171 2171
2172 2172 newheads = len(cl.heads())
2173 2173 heads = ""
2174 2174 if oldheads and newheads != oldheads:
2175 2175 heads = _(" (%+d heads)") % (newheads - oldheads)
2176 2176
2177 2177 self.ui.status(_("added %d changesets"
2178 2178 " with %d changes to %d files%s\n")
2179 2179 % (changesets, revisions, files, heads))
2180 2180
2181 2181 if changesets > 0:
2182 2182 p = lambda: cl.writepending() and self.root or ""
2183 2183 self.hook('pretxnchangegroup', throw=True,
2184 2184 node=hex(cl.node(clstart)), source=srctype,
2185 2185 url=url, pending=p)
2186 2186
2187 2187 # make changelog see real files again
2188 2188 cl.finalize(trp)
2189 2189
2190 2190 tr.close()
2191 2191 finally:
2192 2192 del tr
2193 2193
2194 2194 if changesets > 0:
2195 2195 # forcefully update the on-disk branch cache
2196 2196 self.ui.debug("updating the branch cache\n")
2197 2197 self.branchtags()
2198 2198 self.hook("changegroup", node=hex(cl.node(clstart)),
2199 2199 source=srctype, url=url)
2200 2200
2201 2201 for i in xrange(clstart, clend):
2202 2202 self.hook("incoming", node=hex(cl.node(i)),
2203 2203 source=srctype, url=url)
2204 2204
2205 2205 # never return 0 here:
2206 2206 if newheads < oldheads:
2207 2207 return newheads - oldheads - 1
2208 2208 else:
2209 2209 return newheads - oldheads + 1
2210 2210
2211 2211
2212 2212 def stream_in(self, remote):
2213 2213 fp = remote.stream_out()
2214 2214 l = fp.readline()
2215 2215 try:
2216 2216 resp = int(l)
2217 2217 except ValueError:
2218 2218 raise error.ResponseError(
2219 2219 _('Unexpected response from remote server:'), l)
2220 2220 if resp == 1:
2221 2221 raise util.Abort(_('operation forbidden by server'))
2222 2222 elif resp == 2:
2223 2223 raise util.Abort(_('locking the remote repository failed'))
2224 2224 elif resp != 0:
2225 2225 raise util.Abort(_('the server sent an unknown error code'))
2226 2226 self.ui.status(_('streaming all changes\n'))
2227 2227 l = fp.readline()
2228 2228 try:
2229 2229 total_files, total_bytes = map(int, l.split(' ', 1))
2230 2230 except (ValueError, TypeError):
2231 2231 raise error.ResponseError(
2232 2232 _('Unexpected response from remote server:'), l)
2233 2233 self.ui.status(_('%d files to transfer, %s of data\n') %
2234 2234 (total_files, util.bytecount(total_bytes)))
2235 2235 start = time.time()
2236 2236 for i in xrange(total_files):
2237 2237 # XXX doesn't support '\n' or '\r' in filenames
2238 2238 l = fp.readline()
2239 2239 try:
2240 2240 name, size = l.split('\0', 1)
2241 2241 size = int(size)
2242 2242 except (ValueError, TypeError):
2243 2243 raise error.ResponseError(
2244 2244 _('Unexpected response from remote server:'), l)
2245 2245 self.ui.debug('adding %s (%s)\n' % (name, util.bytecount(size)))
2246 2246 # for backwards compat, name was partially encoded
2247 2247 ofp = self.sopener(store.decodedir(name), 'w')
2248 2248 for chunk in util.filechunkiter(fp, limit=size):
2249 2249 ofp.write(chunk)
2250 2250 ofp.close()
2251 2251 elapsed = time.time() - start
2252 2252 if elapsed <= 0:
2253 2253 elapsed = 0.001
2254 2254 self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %
2255 2255 (util.bytecount(total_bytes), elapsed,
2256 2256 util.bytecount(total_bytes / elapsed)))
2257 2257 self.invalidate()
2258 2258 return len(self.heads()) + 1
2259 2259
2260 2260 def clone(self, remote, heads=[], stream=False):
2261 2261 '''clone remote repository.
2262 2262
2263 2263 keyword arguments:
2264 2264 heads: list of revs to clone (forces use of pull)
2265 2265 stream: use streaming clone if possible'''
2266 2266
2267 2267 # now, all clients that can request uncompressed clones can
2268 2268 # read repo formats supported by all servers that can serve
2269 2269 # them.
2270 2270
2271 2271 # if revlog format changes, client will have to check version
2272 2272 # and format flags on "stream" capability, and use
2273 2273 # uncompressed only if compatible.
2274 2274
2275 2275 if stream and not heads and remote.capable('stream'):
2276 2276 return self.stream_in(remote)
2277 2277 return self.pull(remote, heads)
2278 2278
2279 2279 # used to avoid circular references so destructors work
2280 2280 def aftertrans(files):
2281 2281 renamefiles = [tuple(t) for t in files]
2282 2282 def a():
2283 2283 for src, dest in renamefiles:
2284 2284 util.rename(src, dest)
2285 2285 return a
2286 2286
2287 2287 def instance(ui, path, create):
2288 2288 return localrepository(ui, util.drop_scheme('file', path), create)
2289 2289
2290 2290 def islocal(path):
2291 2291 return True
General Comments 0
You need to be logged in to leave comments. Login now