Show More
@@ -417,7 +417,6 b' elif cmd == "merge":' | |||
|
417 | 417 | if args[0] in paths: args[0] = paths[args[0]] |
|
418 | 418 | |
|
419 | 419 | other = hg.repository(ui, args[0]) |
|
420 | ui.status("requesting changegroup\n") | |
|
421 | 420 | cg = repo.getchangegroup(other) |
|
422 | 421 | repo.addchangegroup(cg) |
|
423 | 422 | else: |
@@ -291,6 +291,7 b' class localrepository:' | |||
|
291 | 291 | return os.path.join(self.path, f) |
|
292 | 292 | |
|
293 | 293 | def file(self, f): |
|
294 | if f[0] == '/': f = f[1:] | |
|
294 | 295 | return filelog(self.opener, f) |
|
295 | 296 | |
|
296 | 297 | def transaction(self): |
@@ -530,6 +531,8 b' class localrepository:' | |||
|
530 | 531 | fetch = [] |
|
531 | 532 | seen = {} |
|
532 | 533 | seenbranch = {} |
|
534 | ||
|
535 | self.ui.status("searching for changes\n") | |
|
533 | 536 | tip = remote.branches([])[0] |
|
534 | 537 | self.ui.debug("remote tip branch is %s:%s\n" % |
|
535 | 538 | (short(tip[0]), short(tip[1]))) |
@@ -542,7 +545,7 b' class localrepository:' | |||
|
542 | 545 | unknown = [tip] |
|
543 | 546 | |
|
544 | 547 | if tip[0] in m: |
|
545 |
self.ui. |
|
|
548 | self.ui.status("nothing to do!\n") | |
|
546 | 549 | return None |
|
547 | 550 | |
|
548 | 551 | while unknown: |
@@ -627,14 +630,13 b' class localrepository:' | |||
|
627 | 630 | # the changegroup is changesets + manifests + all file revs |
|
628 | 631 | revs = [ self.changelog.rev(n) for n in nodes ] |
|
629 | 632 | |
|
630 |
|
|
|
631 |
|
|
|
632 | ||
|
633 | for y in self.changelog.group(linkmap): yield y | |
|
634 | for y in self.manifest.group(linkmap): yield y | |
|
633 | 635 | for f in changed: |
|
636 | yield struct.pack(">l", len(f) + 4) + f | |
|
634 | 637 | g = self.file(f).group(linkmap) |
|
635 | if not g: raise "couldn't find change to %s" % f | |
|
636 | l = struct.pack(">l", len(f)) | |
|
637 | yield "".join([l, f, g]) | |
|
638 | for y in g: | |
|
639 | yield y | |
|
638 | 640 | |
|
639 | 641 | def addchangegroup(self, generator): |
|
640 | 642 | changesets = files = revisions = 0 |
@@ -656,11 +658,18 b' class localrepository:' | |||
|
656 | 658 | if not generator: return |
|
657 | 659 | source = genread(generator) |
|
658 | 660 | |
|
659 |
def getchunk( |
|
|
661 | def getchunk(): | |
|
660 | 662 | d = source.read(4) |
|
661 | 663 | if not d: return "" |
|
662 | 664 | l = struct.unpack(">l", d)[0] |
|
663 | return source.read(l - 4 + add) | |
|
665 | if l <= 4: return "" | |
|
666 | return source.read(l - 4) | |
|
667 | ||
|
668 | def getgroup(): | |
|
669 | while 1: | |
|
670 | c = getchunk() | |
|
671 | if not c: break | |
|
672 | yield c | |
|
664 | 673 | |
|
665 | 674 | tr = self.transaction() |
|
666 | 675 | simple = True |
@@ -671,21 +680,17 b' class localrepository:' | |||
|
671 | 680 | def report(x): |
|
672 | 681 | self.ui.debug("add changeset %s\n" % short(x)) |
|
673 | 682 | return self.changelog.count() |
|
674 | ||
|
675 | csg = getchunk() | |
|
683 | ||
|
676 | 684 | co = self.changelog.tip() |
|
677 |
cn = self.changelog.addgroup( |
|
|
685 | cn = self.changelog.addgroup(getgroup(), report, tr) | |
|
678 | 686 | |
|
679 |
|
|
|
680 | changesets = revisions | |
|
687 | changesets = self.changelog.rev(cn) - self.changelog.rev(co) | |
|
681 | 688 | |
|
682 | 689 | self.ui.status("adding manifests\n") |
|
683 | 690 | # pull off the manifest group |
|
684 | mfg = getchunk() | |
|
685 | 691 | mm = self.manifest.tip() |
|
686 |
mo = self.manifest.addgroup( |
|
|
687 | ||
|
688 | revisions += self.manifest.rev(mo) - self.manifest.rev(mm) | |
|
692 | mo = self.manifest.addgroup(getgroup(), | |
|
693 | lambda x: self.changelog.rev(x), tr) | |
|
689 | 694 | |
|
690 | 695 | # do we need a resolve? |
|
691 | 696 | if self.changelog.ancestor(co, cn) != co: |
@@ -749,13 +754,12 b' class localrepository:' | |||
|
749 | 754 | # process the files |
|
750 | 755 | self.ui.status("adding files\n") |
|
751 | 756 | while 1: |
|
752 |
f = getchunk( |
|
|
757 | f = getchunk() | |
|
753 | 758 | if not f: break |
|
754 | fg = getchunk() | |
|
755 | 759 | self.ui.debug("adding %s revisions\n" % f) |
|
756 | 760 | fl = self.file(f) |
|
757 | 761 | o = fl.tip() |
|
758 |
n = fl.addgroup( |
|
|
762 | n = fl.addgroup(getgroup(), lambda x: self.changelog.rev(x), tr) | |
|
759 | 763 | revisions += fl.rev(n) - fl.rev(o) |
|
760 | 764 | files += 1 |
|
761 | 765 | if f in need: |
@@ -774,9 +778,9 b' class localrepository:' | |||
|
774 | 778 | # For simple merges, we don't need to resolve manifests or changesets |
|
775 | 779 | if simple: |
|
776 | 780 | self.ui.debug("simple merge, skipping resolve\n") |
|
777 |
self.ui.status((" |
|
|
781 | self.ui.status(("modified %d files, added %d changesets" + | |
|
778 | 782 | " and %d new revisions\n") |
|
779 |
% ( |
|
|
783 | % (files, changesets, revisions)) | |
|
780 | 784 | tr.close() |
|
781 | 785 | return |
|
782 | 786 | |
@@ -865,12 +869,15 b' class remoterepository:' | |||
|
865 | 869 | n = " ".join(map(hex, nodes)) |
|
866 | 870 | zd = zlib.decompressobj() |
|
867 | 871 | f = self.do_cmd("changegroup", roots=n) |
|
872 | bytes = 0 | |
|
868 | 873 | while 1: |
|
869 | 874 | d = f.read(4096) |
|
875 | bytes += len(d) | |
|
870 | 876 | if not d: |
|
871 | 877 | yield zd.flush() |
|
872 | 878 | break |
|
873 | 879 | yield zd.decompress(d) |
|
880 | self.ui.note("%d bytes of data transfered\n" % bytes) | |
|
874 | 881 | |
|
875 | 882 | def repository(ui, path=None, create=0): |
|
876 | 883 | if path and path[:7] == "http://": |
@@ -244,8 +244,6 b' class revlog:' | |||
|
244 | 244 | end = self.end(t) |
|
245 | 245 | prev = self.revision(self.tip()) |
|
246 | 246 | d = self.diff(prev, text) |
|
247 | if self.patches(prev, [d]) != text: | |
|
248 | raise AssertionError("diff failed") | |
|
249 | 247 | data = compress(d) |
|
250 | 248 | dist = end - start + len(data) |
|
251 | 249 | |
@@ -330,7 +328,9 b' class revlog:' | |||
|
330 | 328 | needed[i] = 1 |
|
331 | 329 | |
|
332 | 330 | # if we don't have any revisions touched by these changesets, bail |
|
333 | if not revs: return struct.pack(">l", 0) | |
|
331 | if not revs: | |
|
332 | yield struct.pack(">l", 0) | |
|
333 | return | |
|
334 | 334 | |
|
335 | 335 | # add the parent of the first rev |
|
336 | 336 | p = self.parents(self.node(revs[0]))[0] |
@@ -352,25 +352,25 b' class revlog:' | |||
|
352 | 352 | needed = needed.keys() |
|
353 | 353 | needed.sort() |
|
354 | 354 | spans = [] |
|
355 | oo = -1 | |
|
356 | ol = 0 | |
|
355 | 357 | for n in needed: |
|
356 | 358 | if n < 0: continue |
|
357 | 359 | o = self.start(n) |
|
358 | 360 | l = self.length(n) |
|
359 | spans.append((o, l, [(n, l)])) | |
|
360 | ||
|
361 | # merge spans | |
|
362 | merge = [spans.pop(0)] | |
|
363 | while spans: | |
|
364 | e = spans.pop(0) | |
|
365 | f = merge[-1] | |
|
366 | if e[0] == f[0] + f[1]: | |
|
367 | merge[-1] = (f[0], f[1] + e[1], f[2] + e[2]) | |
|
361 | if oo + ol == o: # can we merge with the previous? | |
|
362 | nl = spans[-1][2] | |
|
363 | nl.append((n, l)) | |
|
364 | ol += l | |
|
365 | spans[-1] = (oo, ol, nl) | |
|
368 | 366 | else: |
|
369 |
|
|
|
367 | oo = o | |
|
368 | ol = l | |
|
369 | spans.append((oo, ol, [(n, l)])) | |
|
370 | 370 | |
|
371 | 371 | # read spans in, divide up chunks |
|
372 | 372 | chunks = {} |
|
373 |
for span in |
|
|
373 | for span in spans: | |
|
374 | 374 | # we reopen the file for each span to make http happy for now |
|
375 | 375 | f = self.opener(self.datafile) |
|
376 | 376 | f.seek(span[0]) |
@@ -379,12 +379,12 b' class revlog:' | |||
|
379 | 379 | # divide up the span |
|
380 | 380 | pos = 0 |
|
381 | 381 | for r, l in span[2]: |
|
382 | chunks[r] = data[pos: pos + l] | |
|
382 | chunks[r] = decompress(data[pos: pos + l]) | |
|
383 | 383 | pos += l |
|
384 | 384 | |
|
385 | 385 | # helper to reconstruct intermediate versions |
|
386 | 386 | def construct(text, base, rev): |
|
387 |
bins = [ |
|
|
387 | bins = [chunks[r] for r in xrange(base + 1, rev + 1)] | |
|
388 | 388 | return mdiff.patches(text, bins) |
|
389 | 389 | |
|
390 | 390 | # build deltas |
@@ -392,11 +392,12 b' class revlog:' | |||
|
392 | 392 | for d in xrange(0, len(revs) - 1): |
|
393 | 393 | a, b = revs[d], revs[d + 1] |
|
394 | 394 | n = self.node(b) |
|
395 | ||
|
395 | ||
|
396 | # do we need to construct a new delta? | |
|
396 | 397 | if a + 1 != b or self.base(b) == b: |
|
397 | 398 | if a >= 0: |
|
398 | 399 | base = self.base(a) |
|
399 |
ta = |
|
|
400 | ta = chunks[self.base(a)] | |
|
400 | 401 | ta = construct(ta, base, a) |
|
401 | 402 | else: |
|
402 | 403 | ta = "" |
@@ -406,36 +407,30 b' class revlog:' | |||
|
406 | 407 | base = a |
|
407 | 408 | tb = ta |
|
408 | 409 | else: |
|
409 |
tb = |
|
|
410 | tb = chunks[self.base(b)] | |
|
410 | 411 | tb = construct(tb, base, b) |
|
411 | 412 | d = self.diff(ta, tb) |
|
412 | 413 | else: |
|
413 |
d = |
|
|
414 | d = chunks[b] | |
|
414 | 415 | |
|
415 | 416 | p = self.parents(n) |
|
416 | 417 | meta = n + p[0] + p[1] + linkmap[self.linkrev(n)] |
|
417 | 418 | l = struct.pack(">l", len(meta) + len(d) + 4) |
|
418 | deltas.append(l + meta + d) | |
|
419 | yield l | |
|
420 | yield meta | |
|
421 | yield d | |
|
419 | 422 | |
|
420 |
|
|
|
421 | deltas.insert(0, l) | |
|
422 | return "".join(deltas) | |
|
423 | ||
|
424 | def addgroup(self, data, linkmapper, transaction): | |
|
423 | yield struct.pack(">l", 0) | |
|
424 | ||
|
425 | def addgroup(self, revs, linkmapper, transaction): | |
|
425 | 426 | # given a set of deltas, add them to the revision log. the |
|
426 | 427 | # first delta is against its parent, which should be in our |
|
427 | 428 | # log, the rest are against the previous delta. |
|
428 | 429 | |
|
429 | if not data: return self.tip() | |
|
430 | ||
|
431 | # retrieve the parent revision of the delta chain | |
|
432 | chain = data[24:44] | |
|
433 | if not chain in self.nodemap: | |
|
434 | raise "unknown base %s" % short(chain[:4]) | |
|
435 | ||
|
436 | 430 | # track the base of the current delta log |
|
437 | 431 | r = self.count() |
|
438 | 432 | t = r - 1 |
|
433 | node = nullid | |
|
439 | 434 | |
|
440 | 435 | base = prev = -1 |
|
441 | 436 | start = end = 0 |
@@ -452,15 +447,19 b' class revlog:' | |||
|
452 | 447 | ifh = self.opener(self.indexfile, "a") |
|
453 | 448 | |
|
454 | 449 | # loop through our set of deltas |
|
455 |
|
|
|
456 | while pos < len(data): | |
|
457 |
|
|
|
458 | data[pos:pos+84]) | |
|
450 | chain = None | |
|
451 | for chunk in revs: | |
|
452 | node, p1, p2, cs = struct.unpack("20s20s20s20s", chunk[:80]) | |
|
459 | 453 | link = linkmapper(cs) |
|
460 | 454 | if node in self.nodemap: |
|
461 | 455 | raise "already have %s" % hex(node[:4]) |
|
462 |
delta = |
|
|
463 | pos += l | |
|
456 | delta = chunk[80:] | |
|
457 | ||
|
458 | if not chain: | |
|
459 | # retrieve the parent revision of the delta chain | |
|
460 | chain = p1 | |
|
461 | if not chain in self.nodemap: | |
|
462 | raise "unknown base %s" % short(chain[:4]) | |
|
464 | 463 | |
|
465 | 464 | # full versions are inserted when the needed deltas become |
|
466 | 465 | # comparable to the uncompressed text or when the previous |
General Comments 0
You need to be logged in to leave comments.
Login now