/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Robert Collins
  • Date: 2009-08-17 03:33:56 UTC
  • mto: This revision was merged to the branch mainline in revision 4627.
  • Revision ID: robertc@robertcollins.net-20090817033356-sgmkyhky3y0zayqw
Prepare dirstate tests for 2a as default.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
24
24
    bzrdir,
25
25
    check,
26
26
    chk_map,
27
 
    config,
28
27
    debug,
29
28
    errors,
30
 
    fetch as _mod_fetch,
31
29
    fifo_cache,
32
30
    generate_ids,
33
31
    gpg,
34
32
    graph,
35
33
    inventory,
36
 
    inventory_delta,
37
34
    lazy_regex,
38
35
    lockable_files,
39
36
    lockdir,
40
37
    lru_cache,
41
38
    osutils,
42
39
    revision as _mod_revision,
43
 
    static_tuple,
44
40
    symbol_versioning,
45
 
    trace,
46
41
    tsort,
47
42
    ui,
48
43
    versionedfile,
53
48
from bzrlib.testament import Testament
54
49
""")
55
50
 
56
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
51
from bzrlib.decorators import needs_read_lock, needs_write_lock
57
52
from bzrlib.inter import InterObject
58
53
from bzrlib.inventory import (
59
54
    Inventory,
61
56
    ROOT_ID,
62
57
    entry_factory,
63
58
    )
64
 
from bzrlib.lock import _RelockDebugMixin
65
59
from bzrlib import registry
66
60
from bzrlib.trace import (
67
61
    log_exception_quietly, note, mutter, mutter_callsite, warning)
210
204
            # an inventory delta was accumulated without creating a new
211
205
            # inventory.
212
206
            basis_id = self.basis_delta_revision
213
 
            # We ignore the 'inventory' returned by add_inventory_by_delta
214
 
            # because self.new_inventory is used to hint to the rest of the
215
 
            # system what code path was taken
216
 
            self.inv_sha1, _ = self.repository.add_inventory_by_delta(
 
207
            self.inv_sha1 = self.repository.add_inventory_by_delta(
217
208
                basis_id, self._basis_delta, self._new_revision_id,
218
209
                self.parents)
219
210
        else:
473
464
            if content_summary[2] is None:
474
465
                raise ValueError("Files must not have executable = None")
475
466
            if not store:
476
 
                # We can't trust a check of the file length because of content
477
 
                # filtering...
478
 
                if (# if the exec bit has changed we have to store:
 
467
                if (# if the file length changed we have to store:
 
468
                    parent_entry.text_size != content_summary[1] or
 
469
                    # if the exec bit has changed we have to store:
479
470
                    parent_entry.executable != content_summary[2]):
480
471
                    store = True
481
472
                elif parent_entry.text_sha1 == content_summary[3]:
548
539
                ie.revision = parent_entry.revision
549
540
                return self._get_delta(ie, basis_inv, path), False, None
550
541
            ie.reference_revision = content_summary[3]
551
 
            if ie.reference_revision is None:
552
 
                raise AssertionError("invalid content_summary for nested tree: %r"
553
 
                    % (content_summary,))
554
542
            self._add_text_to_weave(ie.file_id, '', heads, None)
555
543
        else:
556
544
            raise NotImplementedError('unknown kind')
818
806
                seen_root = True
819
807
        self.new_inventory = None
820
808
        if len(inv_delta):
821
 
            # This should perhaps be guarded by a check that the basis we
822
 
            # commit against is the basis for the commit and if not do a delta
823
 
            # against the basis.
824
809
            self._any_changes = True
825
810
        if not seen_root:
826
811
            # housekeeping root entry changes do not affect no-change commits.
864
849
# Repositories
865
850
 
866
851
 
867
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
852
class Repository(object):
868
853
    """Repository holding history for one or more branches.
869
854
 
870
855
    The repository holds and retrieves historical information including
939
924
        """
940
925
        if self._write_group is not self.get_transaction():
941
926
            # has an unlock or relock occured ?
942
 
            if suppress_errors:
943
 
                mutter(
944
 
                '(suppressed) mismatched lock context and write group. %r, %r',
945
 
                self._write_group, self.get_transaction())
946
 
                return
947
927
            raise errors.BzrError(
948
928
                'mismatched lock context and write group. %r, %r' %
949
929
                (self._write_group, self.get_transaction()))
1028
1008
 
1029
1009
        :seealso: add_inventory, for the contract.
1030
1010
        """
1031
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1011
        inv_lines = self._serialise_inventory_to_lines(inv)
1032
1012
        return self._inventory_add_lines(revision_id, parents,
1033
1013
            inv_lines, check_content=False)
1034
1014
 
1083
1063
        check_content=True):
1084
1064
        """Store lines in inv_vf and return the sha1 of the inventory."""
1085
1065
        parents = [(parent,) for parent in parents]
1086
 
        result = self.inventories.add_lines((revision_id,), parents, lines,
 
1066
        return self.inventories.add_lines((revision_id,), parents, lines,
1087
1067
            check_content=check_content)[0]
1088
 
        self.inventories._access.flush()
1089
 
        return result
1090
1068
 
1091
1069
    def add_revision(self, revision_id, rev, inv=None, config=None):
1092
1070
        """Add rev to the revision store as revision_id.
1230
1208
                    for record in getattr(self, kind).check(keys=keys[kind]):
1231
1209
                        if record.storage_kind == 'absent':
1232
1210
                            checker._report_items.append(
1233
 
                                'Missing %s {%s}' % (kind, record.key,))
 
1211
                                'Missing inventory {%s}' % (record.key,))
1234
1212
                        else:
1235
1213
                            last_object = self._check_record(kind, record,
1236
1214
                                checker, last_object, current_keys[(kind,) + record.key])
1241
1219
        """Check a single text from this repository."""
1242
1220
        if kind == 'inventories':
1243
1221
            rev_id = record.key[0]
1244
 
            inv = self._deserialise_inventory(rev_id,
 
1222
            inv = self.deserialise_inventory(rev_id,
1245
1223
                record.get_bytes_as('fulltext'))
1246
1224
            if last_object is not None:
1247
1225
                delta = inv._make_delta(last_object)
1291
1269
 
1292
1270
        :param _format: The format of the repository on disk.
1293
1271
        :param a_bzrdir: The BzrDir of the repository.
 
1272
 
 
1273
        In the future we will have a single api for all stores for
 
1274
        getting file texts, inventories and revisions, then
 
1275
        this construct will accept instances of those things.
1294
1276
        """
1295
 
        # In the future we will have a single api for all stores for
1296
 
        # getting file texts, inventories and revisions, then
1297
 
        # this construct will accept instances of those things.
1298
1277
        super(Repository, self).__init__()
1299
1278
        self._format = _format
1300
1279
        # the following are part of the public API for Repository:
1306
1285
        self._reconcile_does_inventory_gc = True
1307
1286
        self._reconcile_fixes_text_parents = False
1308
1287
        self._reconcile_backsup_inventory = True
 
1288
        # not right yet - should be more semantically clear ?
 
1289
        #
 
1290
        # TODO: make sure to construct the right store classes, etc, depending
 
1291
        # on whether escaping is required.
 
1292
        self._warn_if_deprecated()
1309
1293
        self._write_group = None
1310
1294
        # Additional places to query for data.
1311
1295
        self._fallback_repositories = []
1312
1296
        # An InventoryEntry cache, used during deserialization
1313
1297
        self._inventory_entry_cache = fifo_cache.FIFOCache(10*1024)
1314
 
        # Is it safe to return inventory entries directly from the entry cache,
1315
 
        # rather copying them?
1316
 
        self._safe_to_return_from_cache = False
1317
 
 
1318
 
    @property
1319
 
    def user_transport(self):
1320
 
        return self.bzrdir.user_transport
1321
 
 
1322
 
    @property
1323
 
    def control_transport(self):
1324
 
        return self._transport
1325
1298
 
1326
1299
    def __repr__(self):
1327
1300
        if self._fallback_repositories:
1394
1367
        locked = self.is_locked()
1395
1368
        result = self.control_files.lock_write(token=token)
1396
1369
        if not locked:
1397
 
            self._warn_if_deprecated()
1398
 
            self._note_lock('w')
1399
1370
            for repo in self._fallback_repositories:
1400
1371
                # Writes don't affect fallback repos
1401
1372
                repo.lock_read()
1406
1377
        locked = self.is_locked()
1407
1378
        self.control_files.lock_read()
1408
1379
        if not locked:
1409
 
            self._warn_if_deprecated()
1410
 
            self._note_lock('r')
1411
1380
            for repo in self._fallback_repositories:
1412
1381
                repo.lock_read()
1413
1382
            self._refresh_data()
1476
1445
 
1477
1446
        # now gather global repository information
1478
1447
        # XXX: This is available for many repos regardless of listability.
1479
 
        if self.user_transport.listable():
 
1448
        if self.bzrdir.root_transport.listable():
1480
1449
            # XXX: do we want to __define len__() ?
1481
1450
            # Maybe the versionedfiles object should provide a different
1482
1451
            # method to get the number of keys.
1492
1461
        :param using: If True, list only branches using this repository.
1493
1462
        """
1494
1463
        if using and not self.is_shared():
1495
 
            return self.bzrdir.list_branches()
 
1464
            try:
 
1465
                return [self.bzrdir.open_branch()]
 
1466
            except errors.NotBranchError:
 
1467
                return []
1496
1468
        class Evaluator(object):
1497
1469
 
1498
1470
            def __init__(self):
1507
1479
                    except errors.NoRepositoryPresent:
1508
1480
                        pass
1509
1481
                    else:
1510
 
                        return False, ([], repository)
 
1482
                        return False, (None, repository)
1511
1483
                self.first_call = False
1512
 
                value = (bzrdir.list_branches(), None)
 
1484
                try:
 
1485
                    value = (bzrdir.open_branch(), None)
 
1486
                except errors.NotBranchError:
 
1487
                    value = (None, None)
1513
1488
                return True, value
1514
1489
 
1515
 
        ret = []
1516
 
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1517
 
                self.user_transport, evaluate=Evaluator()):
1518
 
            if branches is not None:
1519
 
                ret.extend(branches)
 
1490
        branches = []
 
1491
        for branch, repository in bzrdir.BzrDir.find_bzrdirs(
 
1492
                self.bzrdir.root_transport, evaluate=Evaluator()):
 
1493
            if branch is not None:
 
1494
                branches.append(branch)
1520
1495
            if not using and repository is not None:
1521
 
                ret.extend(repository.find_branches())
1522
 
        return ret
 
1496
                branches.extend(repository.find_branches())
 
1497
        return branches
1523
1498
 
1524
1499
    @needs_read_lock
1525
1500
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1554
1529
        """Commit the contents accrued within the current write group.
1555
1530
 
1556
1531
        :seealso: start_write_group.
1557
 
        
1558
 
        :return: it may return an opaque hint that can be passed to 'pack'.
1559
1532
        """
1560
1533
        if self._write_group is not self.get_transaction():
1561
1534
            # has an unlock or relock occured ?
1615
1588
        # but at the moment we're only checking for texts referenced by
1616
1589
        # inventories at the graph's edge.
1617
1590
        key_deps = self.revisions._index._key_dependencies
1618
 
        key_deps.satisfy_refs_for_keys(present_inventories)
 
1591
        key_deps.add_keys(present_inventories)
1619
1592
        referrers = frozenset(r[0] for r in key_deps.get_referrers())
1620
1593
        file_ids = self.fileids_altered_by_revision_ids(referrers)
1621
1594
        missing_texts = set()
1731
1704
        self.start_write_group()
1732
1705
        return result
1733
1706
 
1734
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1735
1707
    def unlock(self):
1736
1708
        if (self.control_files._lock_count == 1 and
1737
1709
            self.control_files._lock_mode == 'w'):
1903
1875
                rev = self._serializer.read_revision_from_string(text)
1904
1876
                yield (revid, rev)
1905
1877
 
 
1878
    @needs_read_lock
 
1879
    def get_revision_xml(self, revision_id):
 
1880
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1881
        #       would have already do it.
 
1882
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1883
        # TODO: this can't just be replaced by:
 
1884
        # return self._serializer.write_revision_to_string(
 
1885
        #     self.get_revision(revision_id))
 
1886
        # as cStringIO preservers the encoding unlike write_revision_to_string
 
1887
        # or some other call down the path.
 
1888
        rev = self.get_revision(revision_id)
 
1889
        rev_tmp = cStringIO.StringIO()
 
1890
        # the current serializer..
 
1891
        self._serializer.write_revision(rev, rev_tmp)
 
1892
        rev_tmp.seek(0)
 
1893
        return rev_tmp.getvalue()
 
1894
 
1906
1895
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1907
1896
        """Produce a generator of revision deltas.
1908
1897
 
2150
2139
        """
2151
2140
        selected_keys = set((revid,) for revid in revision_ids)
2152
2141
        w = _inv_weave or self.inventories
2153
 
        return self._find_file_ids_from_xml_inventory_lines(
2154
 
            w.iter_lines_added_or_present_in_keys(
2155
 
                selected_keys, pb=None),
2156
 
            selected_keys)
 
2142
        pb = ui.ui_factory.nested_progress_bar()
 
2143
        try:
 
2144
            return self._find_file_ids_from_xml_inventory_lines(
 
2145
                w.iter_lines_added_or_present_in_keys(
 
2146
                    selected_keys, pb=pb),
 
2147
                selected_keys)
 
2148
        finally:
 
2149
            pb.finished()
2157
2150
 
2158
2151
    def iter_files_bytes(self, desired_files):
2159
2152
        """Iterate through file versions.
2320
2313
        num_file_ids = len(file_ids)
2321
2314
        for file_id, altered_versions in file_ids.iteritems():
2322
2315
            if pb is not None:
2323
 
                pb.update("Fetch texts", count, num_file_ids)
 
2316
                pb.update("fetch texts", count, num_file_ids)
2324
2317
            count += 1
2325
2318
            yield ("file", file_id, altered_versions)
2326
2319
 
2347
2340
        """Get Inventory object by revision id."""
2348
2341
        return self.iter_inventories([revision_id]).next()
2349
2342
 
2350
 
    def iter_inventories(self, revision_ids, ordering=None):
 
2343
    def iter_inventories(self, revision_ids):
2351
2344
        """Get many inventories by revision_ids.
2352
2345
 
2353
2346
        This will buffer some or all of the texts used in constructing the
2355
2348
        time.
2356
2349
 
2357
2350
        :param revision_ids: The expected revision ids of the inventories.
2358
 
        :param ordering: optional ordering, e.g. 'topological'.  If not
2359
 
            specified, the order of revision_ids will be preserved (by
2360
 
            buffering if necessary).
2361
2351
        :return: An iterator of inventories.
2362
2352
        """
2363
2353
        if ((None in revision_ids)
2364
2354
            or (_mod_revision.NULL_REVISION in revision_ids)):
2365
2355
            raise ValueError('cannot get null revision inventory')
2366
 
        return self._iter_inventories(revision_ids, ordering)
 
2356
        return self._iter_inventories(revision_ids)
2367
2357
 
2368
 
    def _iter_inventories(self, revision_ids, ordering):
 
2358
    def _iter_inventories(self, revision_ids):
2369
2359
        """single-document based inventory iteration."""
2370
 
        inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2371
 
        for text, revision_id in inv_xmls:
2372
 
            yield self._deserialise_inventory(revision_id, text)
 
2360
        for text, revision_id in self._iter_inventory_xmls(revision_ids):
 
2361
            yield self.deserialise_inventory(revision_id, text)
2373
2362
 
2374
 
    def _iter_inventory_xmls(self, revision_ids, ordering):
2375
 
        if ordering is None:
2376
 
            order_as_requested = True
2377
 
            ordering = 'unordered'
2378
 
        else:
2379
 
            order_as_requested = False
 
2363
    def _iter_inventory_xmls(self, revision_ids):
2380
2364
        keys = [(revision_id,) for revision_id in revision_ids]
2381
 
        if not keys:
2382
 
            return
2383
 
        if order_as_requested:
2384
 
            key_iter = iter(keys)
2385
 
            next_key = key_iter.next()
2386
 
        stream = self.inventories.get_record_stream(keys, ordering, True)
 
2365
        stream = self.inventories.get_record_stream(keys, 'unordered', True)
2387
2366
        text_chunks = {}
2388
2367
        for record in stream:
2389
2368
            if record.storage_kind != 'absent':
2390
 
                chunks = record.get_bytes_as('chunked')
2391
 
                if order_as_requested:
2392
 
                    text_chunks[record.key] = chunks
2393
 
                else:
2394
 
                    yield ''.join(chunks), record.key[-1]
 
2369
                text_chunks[record.key] = record.get_bytes_as('chunked')
2395
2370
            else:
2396
2371
                raise errors.NoSuchRevision(self, record.key)
2397
 
            if order_as_requested:
2398
 
                # Yield as many results as we can while preserving order.
2399
 
                while next_key in text_chunks:
2400
 
                    chunks = text_chunks.pop(next_key)
2401
 
                    yield ''.join(chunks), next_key[-1]
2402
 
                    try:
2403
 
                        next_key = key_iter.next()
2404
 
                    except StopIteration:
2405
 
                        # We still want to fully consume the get_record_stream,
2406
 
                        # just in case it is not actually finished at this point
2407
 
                        next_key = None
2408
 
                        break
 
2372
        for key in keys:
 
2373
            chunks = text_chunks.pop(key)
 
2374
            yield ''.join(chunks), key[-1]
2409
2375
 
2410
 
    def _deserialise_inventory(self, revision_id, xml):
 
2376
    def deserialise_inventory(self, revision_id, xml):
2411
2377
        """Transform the xml into an inventory object.
2412
2378
 
2413
2379
        :param revision_id: The expected revision id of the inventory.
2414
2380
        :param xml: A serialised inventory.
2415
2381
        """
2416
2382
        result = self._serializer.read_inventory_from_string(xml, revision_id,
2417
 
                    entry_cache=self._inventory_entry_cache,
2418
 
                    return_from_cache=self._safe_to_return_from_cache)
 
2383
                    entry_cache=self._inventory_entry_cache)
2419
2384
        if result.revision_id != revision_id:
2420
2385
            raise AssertionError('revision id mismatch %s != %s' % (
2421
2386
                result.revision_id, revision_id))
2422
2387
        return result
2423
2388
 
 
2389
    def serialise_inventory(self, inv):
 
2390
        return self._serializer.write_inventory_to_string(inv)
 
2391
 
 
2392
    def _serialise_inventory_to_lines(self, inv):
 
2393
        return self._serializer.write_inventory_to_lines(inv)
 
2394
 
2424
2395
    def get_serializer_format(self):
2425
2396
        return self._serializer.format_num
2426
2397
 
2427
2398
    @needs_read_lock
2428
 
    def _get_inventory_xml(self, revision_id):
2429
 
        """Get serialized inventory as a string."""
2430
 
        texts = self._iter_inventory_xmls([revision_id], 'unordered')
 
2399
    def get_inventory_xml(self, revision_id):
 
2400
        """Get inventory XML as a file object."""
 
2401
        texts = self._iter_inventory_xmls([revision_id])
2431
2402
        try:
2432
2403
            text, revision_id = texts.next()
2433
2404
        except StopIteration:
2434
2405
            raise errors.HistoryMissing(self, 'inventory', revision_id)
2435
2406
        return text
2436
2407
 
 
2408
    @needs_read_lock
 
2409
    def get_inventory_sha1(self, revision_id):
 
2410
        """Return the sha1 hash of the inventory entry
 
2411
        """
 
2412
        return self.get_revision(revision_id).inventory_sha1
 
2413
 
2437
2414
    def get_rev_id_for_revno(self, revno, known_pair):
2438
2415
        """Return the revision id of a revno, given a later (revno, revid)
2439
2416
        pair in the same history.
2490
2467
            else:
2491
2468
                next_id = parents[0]
2492
2469
 
 
2470
    @needs_read_lock
 
2471
    def get_revision_inventory(self, revision_id):
 
2472
        """Return inventory of a past revision."""
 
2473
        # TODO: Unify this with get_inventory()
 
2474
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
2475
        # must be the same as its revision, so this is trivial.
 
2476
        if revision_id is None:
 
2477
            # This does not make sense: if there is no revision,
 
2478
            # then it is the current tree inventory surely ?!
 
2479
            # and thus get_root_id() is something that looks at the last
 
2480
            # commit on the branch, and the get_root_id is an inventory check.
 
2481
            raise NotImplementedError
 
2482
            # return Inventory(self.get_root_id())
 
2483
        else:
 
2484
            return self.get_inventory(revision_id)
 
2485
 
2493
2486
    def is_shared(self):
2494
2487
        """Return True if this repository is flagged as a shared repository."""
2495
2488
        raise NotImplementedError(self.is_shared)
2529
2522
            return RevisionTree(self, Inventory(root_id=None),
2530
2523
                                _mod_revision.NULL_REVISION)
2531
2524
        else:
2532
 
            inv = self.get_inventory(revision_id)
 
2525
            inv = self.get_revision_inventory(revision_id)
2533
2526
            return RevisionTree(self, inv, revision_id)
2534
2527
 
2535
2528
    def revision_trees(self, revision_ids):
2588
2581
            keys = tsort.topo_sort(parent_map)
2589
2582
        return [None] + list(keys)
2590
2583
 
2591
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2584
    def pack(self, hint=None):
2592
2585
        """Compress the data within the repository.
2593
2586
 
2594
2587
        This operation only makes sense for some repository types. For other
2604
2597
            obtained from the result of commit_write_group(). Out of
2605
2598
            date hints are simply ignored, because concurrent operations
2606
2599
            can obsolete them rapidly.
2607
 
 
2608
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2609
 
            the pack operation.
2610
2600
        """
2611
2601
 
2612
2602
    def get_transaction(self):
2628
2618
        for ((revision_id,), parent_keys) in \
2629
2619
                self.revisions.get_parent_map(query_keys).iteritems():
2630
2620
            if parent_keys:
2631
 
                result[revision_id] = tuple([parent_revid
2632
 
                    for (parent_revid,) in parent_keys])
 
2621
                result[revision_id] = tuple(parent_revid
 
2622
                    for (parent_revid,) in parent_keys)
2633
2623
            else:
2634
2624
                result[revision_id] = (_mod_revision.NULL_REVISION,)
2635
2625
        return result
2637
2627
    def _make_parents_provider(self):
2638
2628
        return self
2639
2629
 
2640
 
    @needs_read_lock
2641
 
    def get_known_graph_ancestry(self, revision_ids):
2642
 
        """Return the known graph for a set of revision ids and their ancestors.
2643
 
        """
2644
 
        st = static_tuple.StaticTuple
2645
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
2646
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2647
 
        return graph.GraphThunkIdsToKeys(known_graph)
2648
 
 
2649
2630
    def get_graph(self, other_repository=None):
2650
2631
        """Return the graph walker for this repository format"""
2651
2632
        parents_provider = self._make_parents_provider()
2746
2727
        result.check(callback_refs)
2747
2728
        return result
2748
2729
 
2749
 
    def _warn_if_deprecated(self, branch=None):
 
2730
    def _warn_if_deprecated(self):
2750
2731
        global _deprecation_warning_done
2751
2732
        if _deprecation_warning_done:
2752
2733
            return
2753
 
        try:
2754
 
            if branch is None:
2755
 
                conf = config.GlobalConfig()
2756
 
            else:
2757
 
                conf = branch.get_config()
2758
 
            if conf.suppress_warning('format_deprecation'):
2759
 
                return
2760
 
            warning("Format %s for %s is deprecated -"
2761
 
                    " please use 'bzr upgrade' to get better performance"
2762
 
                    % (self._format, self.bzrdir.transport.base))
2763
 
        finally:
2764
 
            _deprecation_warning_done = True
 
2734
        _deprecation_warning_done = True
 
2735
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
2736
                % (self._format, self.bzrdir.transport.base))
2765
2737
 
2766
2738
    def supports_rich_root(self):
2767
2739
        return self._format.rich_root_data
3050
3022
    pack_compresses = False
3051
3023
    # Does the repository inventory storage understand references to trees?
3052
3024
    supports_tree_reference = None
3053
 
    # Is the format experimental ?
3054
 
    experimental = False
3055
3025
 
3056
 
    def __repr__(self):
3057
 
        return "%s()" % self.__class__.__name__
 
3026
    def __str__(self):
 
3027
        return "<%s>" % self.__class__.__name__
3058
3028
 
3059
3029
    def __eq__(self, other):
3060
3030
        # format objects are generally stateless
3073
3043
        """
3074
3044
        try:
3075
3045
            transport = a_bzrdir.get_repository_transport(None)
3076
 
            format_string = transport.get_bytes("format")
 
3046
            format_string = transport.get("format").read()
3077
3047
            return format_registry.get(format_string)
3078
3048
        except errors.NoSuchFile:
3079
3049
            raise errors.NoRepositoryPresent(a_bzrdir)
3161
3131
        raise NotImplementedError(self.network_name)
3162
3132
 
3163
3133
    def check_conversion_target(self, target_format):
3164
 
        if self.rich_root_data and not target_format.rich_root_data:
3165
 
            raise errors.BadConversionTarget(
3166
 
                'Does not support rich root data.', target_format,
3167
 
                from_format=self)
3168
 
        if (self.supports_tree_reference and 
3169
 
            not getattr(target_format, 'supports_tree_reference', False)):
3170
 
            raise errors.BadConversionTarget(
3171
 
                'Does not support nested trees', target_format,
3172
 
                from_format=self)
 
3134
        raise NotImplementedError(self.check_conversion_target)
3173
3135
 
3174
3136
    def open(self, a_bzrdir, _found=False):
3175
3137
        """Return an instance of this format for the bzrdir a_bzrdir.
3178
3140
        """
3179
3141
        raise NotImplementedError(self.open)
3180
3142
 
3181
 
    def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3182
 
        from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3183
 
        hooks = BzrDir.hooks['post_repo_init']
3184
 
        if not hooks:
3185
 
            return
3186
 
        params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3187
 
        for hook in hooks:
3188
 
            hook(params)
3189
 
 
3190
3143
 
3191
3144
class MetaDirRepositoryFormat(RepositoryFormat):
3192
3145
    """Common base class for the new repositories using the metadir layout."""
3397
3350
 
3398
3351
        :param revision_id: if None all content is copied, if NULL_REVISION no
3399
3352
                            content is copied.
3400
 
        :param pb: ignored.
 
3353
        :param pb: optional progress bar to use for progress reports. If not
 
3354
                   provided a default one will be created.
3401
3355
        :return: None.
3402
3356
        """
3403
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3404
3357
        from bzrlib.fetch import RepoFetcher
3405
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
3406
 
        if self.source._format.network_name() != self.target._format.network_name():
3407
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
3408
 
                from_format=self.source._format,
3409
 
                to_format=self.target._format)
3410
3358
        f = RepoFetcher(to_repository=self.target,
3411
3359
                               from_repository=self.source,
3412
3360
                               last_revision=revision_id,
3413
3361
                               fetch_spec=fetch_spec,
3414
 
                               find_ghosts=find_ghosts)
 
3362
                               pb=pb, find_ghosts=find_ghosts)
3415
3363
 
3416
3364
    def _walk_to_common_revisions(self, revision_ids):
3417
3365
        """Walk out from revision_ids in source to revisions target has.
3586
3534
                self.target.texts.insert_record_stream(
3587
3535
                    self.source.texts.get_record_stream(
3588
3536
                        self.source.texts.keys(), 'topological', False))
3589
 
                pb.update('Copying inventory', 0, 1)
 
3537
                pb.update('copying inventory', 0, 1)
3590
3538
                self.target.inventories.insert_record_stream(
3591
3539
                    self.source.inventories.get_record_stream(
3592
3540
                        self.source.inventories.keys(), 'topological', False))
3718
3666
        # This is redundant with format.check_conversion_target(), however that
3719
3667
        # raises an exception, and we just want to say "False" as in we won't
3720
3668
        # support converting between these formats.
3721
 
        if 'IDS_never' in debug.debug_flags:
3722
 
            return False
3723
3669
        if source.supports_rich_root() and not target.supports_rich_root():
3724
3670
            return False
3725
3671
        if (source._format.supports_tree_reference
3726
3672
            and not target._format.supports_tree_reference):
3727
3673
            return False
3728
 
        if target._fallback_repositories and target._format.supports_chks:
3729
 
            # IDS doesn't know how to copy CHKs for the parent inventories it
3730
 
            # adds to stacked repos.
3731
 
            return False
3732
 
        if 'IDS_always' in debug.debug_flags:
3733
 
            return True
3734
 
        # Only use this code path for local source and target.  IDS does far
3735
 
        # too much IO (both bandwidth and roundtrips) over a network.
3736
 
        if not source.bzrdir.transport.base.startswith('file:///'):
3737
 
            return False
3738
 
        if not target.bzrdir.transport.base.startswith('file:///'):
3739
 
            return False
3740
3674
        return True
3741
3675
 
3742
 
    def _get_trees(self, revision_ids, cache):
3743
 
        possible_trees = []
3744
 
        for rev_id in revision_ids:
3745
 
            if rev_id in cache:
3746
 
                possible_trees.append((rev_id, cache[rev_id]))
3747
 
            else:
3748
 
                # Not cached, but inventory might be present anyway.
3749
 
                try:
3750
 
                    tree = self.source.revision_tree(rev_id)
3751
 
                except errors.NoSuchRevision:
3752
 
                    # Nope, parent is ghost.
3753
 
                    pass
3754
 
                else:
3755
 
                    cache[rev_id] = tree
3756
 
                    possible_trees.append((rev_id, tree))
3757
 
        return possible_trees
3758
 
 
3759
 
    def _get_delta_for_revision(self, tree, parent_ids, possible_trees):
 
3676
    def _get_delta_for_revision(self, tree, parent_ids, basis_id, cache):
3760
3677
        """Get the best delta and base for this revision.
3761
3678
 
3762
3679
        :return: (basis_id, delta)
3763
3680
        """
 
3681
        possible_trees = [(parent_id, cache[parent_id])
 
3682
                          for parent_id in parent_ids
 
3683
                           if parent_id in cache]
 
3684
        if len(possible_trees) == 0:
 
3685
            # There either aren't any parents, or the parents aren't in the
 
3686
            # cache, so just use the last converted tree
 
3687
            possible_trees.append((basis_id, cache[basis_id]))
3764
3688
        deltas = []
3765
 
        # Generate deltas against each tree, to find the shortest.
3766
 
        texts_possibly_new_in_tree = set()
3767
3689
        for basis_id, basis_tree in possible_trees:
3768
3690
            delta = tree.inventory._make_delta(basis_tree.inventory)
3769
 
            for old_path, new_path, file_id, new_entry in delta:
3770
 
                if new_path is None:
3771
 
                    # This file_id isn't present in the new rev, so we don't
3772
 
                    # care about it.
3773
 
                    continue
3774
 
                if not new_path:
3775
 
                    # Rich roots are handled elsewhere...
3776
 
                    continue
3777
 
                kind = new_entry.kind
3778
 
                if kind != 'directory' and kind != 'file':
3779
 
                    # No text record associated with this inventory entry.
3780
 
                    continue
3781
 
                # This is a directory or file that has changed somehow.
3782
 
                texts_possibly_new_in_tree.add((file_id, new_entry.revision))
3783
3691
            deltas.append((len(delta), basis_id, delta))
3784
3692
        deltas.sort()
3785
3693
        return deltas[0][1:]
3786
3694
 
3787
 
    def _fetch_parent_invs_for_stacking(self, parent_map, cache):
3788
 
        """Find all parent revisions that are absent, but for which the
3789
 
        inventory is present, and copy those inventories.
3790
 
 
3791
 
        This is necessary to preserve correctness when the source is stacked
3792
 
        without fallbacks configured.  (Note that in cases like upgrade the
3793
 
        source may be not have _fallback_repositories even though it is
3794
 
        stacked.)
3795
 
        """
3796
 
        parent_revs = set()
3797
 
        for parents in parent_map.values():
3798
 
            parent_revs.update(parents)
3799
 
        present_parents = self.source.get_parent_map(parent_revs)
3800
 
        absent_parents = set(parent_revs).difference(present_parents)
3801
 
        parent_invs_keys_for_stacking = self.source.inventories.get_parent_map(
3802
 
            (rev_id,) for rev_id in absent_parents)
3803
 
        parent_inv_ids = [key[-1] for key in parent_invs_keys_for_stacking]
3804
 
        for parent_tree in self.source.revision_trees(parent_inv_ids):
3805
 
            current_revision_id = parent_tree.get_revision_id()
3806
 
            parents_parents_keys = parent_invs_keys_for_stacking[
3807
 
                (current_revision_id,)]
3808
 
            parents_parents = [key[-1] for key in parents_parents_keys]
3809
 
            basis_id = _mod_revision.NULL_REVISION
3810
 
            basis_tree = self.source.revision_tree(basis_id)
3811
 
            delta = parent_tree.inventory._make_delta(basis_tree.inventory)
3812
 
            self.target.add_inventory_by_delta(
3813
 
                basis_id, delta, current_revision_id, parents_parents)
3814
 
            cache[current_revision_id] = parent_tree
3815
 
 
3816
 
    def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
 
3695
    def _get_parent_keys(self, root_key, parent_map):
 
3696
        """Get the parent keys for a given root id."""
 
3697
        root_id, rev_id = root_key
 
3698
        # Include direct parents of the revision, but only if they used
 
3699
        # the same root_id and are heads.
 
3700
        parent_keys = []
 
3701
        for parent_id in parent_map[rev_id]:
 
3702
            if parent_id == _mod_revision.NULL_REVISION:
 
3703
                continue
 
3704
            if parent_id not in self._revision_id_to_root_id:
 
3705
                # We probably didn't read this revision, go spend the
 
3706
                # extra effort to actually check
 
3707
                try:
 
3708
                    tree = self.source.revision_tree(parent_id)
 
3709
                except errors.NoSuchRevision:
 
3710
                    # Ghost, fill out _revision_id_to_root_id in case we
 
3711
                    # encounter this again.
 
3712
                    # But set parent_root_id to None since we don't really know
 
3713
                    parent_root_id = None
 
3714
                else:
 
3715
                    parent_root_id = tree.get_root_id()
 
3716
                self._revision_id_to_root_id[parent_id] = None
 
3717
            else:
 
3718
                parent_root_id = self._revision_id_to_root_id[parent_id]
 
3719
            if root_id == parent_root_id:
 
3720
                # With stacking we _might_ want to refer to a non-local
 
3721
                # revision, but this code path only applies when we have the
 
3722
                # full content available, so ghosts really are ghosts, not just
 
3723
                # the edge of local data.
 
3724
                parent_keys.append((parent_id,))
 
3725
            else:
 
3726
                # root_id may be in the parent anyway.
 
3727
                try:
 
3728
                    tree = self.source.revision_tree(parent_id)
 
3729
                except errors.NoSuchRevision:
 
3730
                    # ghost, can't refer to it.
 
3731
                    pass
 
3732
                else:
 
3733
                    try:
 
3734
                        parent_keys.append((tree.inventory[root_id].revision,))
 
3735
                    except errors.NoSuchId:
 
3736
                        # not in the tree
 
3737
                        pass
 
3738
        g = graph.Graph(self.source.revisions)
 
3739
        heads = g.heads(parent_keys)
 
3740
        selected_keys = []
 
3741
        for key in parent_keys:
 
3742
            if key in heads and key not in selected_keys:
 
3743
                selected_keys.append(key)
 
3744
        return tuple([(root_id,)+ key for key in selected_keys])
 
3745
 
 
3746
    def _new_root_data_stream(self, root_keys_to_create, parent_map):
 
3747
        for root_key in root_keys_to_create:
 
3748
            parent_keys = self._get_parent_keys(root_key, parent_map)
 
3749
            yield versionedfile.FulltextContentFactory(root_key,
 
3750
                parent_keys, None, '')
 
3751
 
 
3752
    def _fetch_batch(self, revision_ids, basis_id, cache):
3817
3753
        """Fetch across a few revisions.
3818
3754
 
3819
3755
        :param revision_ids: The revisions to copy
3820
3756
        :param basis_id: The revision_id of a tree that must be in cache, used
3821
3757
            as a basis for delta when no other base is available
3822
3758
        :param cache: A cache of RevisionTrees that we can use.
3823
 
        :param a_graph: A Graph object to determine the heads() of the
3824
 
            rich-root data stream.
3825
3759
        :return: The revision_id of the last converted tree. The RevisionTree
3826
3760
            for it will be in cache
3827
3761
        """
3833
3767
        pending_deltas = []
3834
3768
        pending_revisions = []
3835
3769
        parent_map = self.source.get_parent_map(revision_ids)
3836
 
        self._fetch_parent_invs_for_stacking(parent_map, cache)
3837
 
        self.source._safe_to_return_from_cache = True
3838
3770
        for tree in self.source.revision_trees(revision_ids):
3839
 
            # Find a inventory delta for this revision.
3840
 
            # Find text entries that need to be copied, too.
3841
3771
            current_revision_id = tree.get_revision_id()
3842
3772
            parent_ids = parent_map.get(current_revision_id, ())
3843
 
            parent_trees = self._get_trees(parent_ids, cache)
3844
 
            possible_trees = list(parent_trees)
3845
 
            if len(possible_trees) == 0:
3846
 
                # There either aren't any parents, or the parents are ghosts,
3847
 
                # so just use the last converted tree.
3848
 
                possible_trees.append((basis_id, cache[basis_id]))
3849
3773
            basis_id, delta = self._get_delta_for_revision(tree, parent_ids,
3850
 
                                                           possible_trees)
3851
 
            revision = self.source.get_revision(current_revision_id)
3852
 
            pending_deltas.append((basis_id, delta,
3853
 
                current_revision_id, revision.parent_ids))
 
3774
                                                           basis_id, cache)
3854
3775
            if self._converting_to_rich_root:
3855
3776
                self._revision_id_to_root_id[current_revision_id] = \
3856
3777
                    tree.get_root_id()
3857
 
            # Determine which texts are in present in this revision but not in
3858
 
            # any of the available parents.
3859
 
            texts_possibly_new_in_tree = set()
 
3778
            # Find text entries that need to be copied
3860
3779
            for old_path, new_path, file_id, entry in delta:
3861
 
                if new_path is None:
3862
 
                    # This file_id isn't present in the new rev
3863
 
                    continue
3864
 
                if not new_path:
3865
 
                    # This is the root
3866
 
                    if not self.target.supports_rich_root():
3867
 
                        # The target doesn't support rich root, so we don't
3868
 
                        # copy
3869
 
                        continue
3870
 
                    if self._converting_to_rich_root:
3871
 
                        # This can't be copied normally, we have to insert
3872
 
                        # it specially
3873
 
                        root_keys_to_create.add((file_id, entry.revision))
3874
 
                        continue
3875
 
                kind = entry.kind
3876
 
                texts_possibly_new_in_tree.add((file_id, entry.revision))
3877
 
            for basis_id, basis_tree in possible_trees:
3878
 
                basis_inv = basis_tree.inventory
3879
 
                for file_key in list(texts_possibly_new_in_tree):
3880
 
                    file_id, file_revision = file_key
3881
 
                    try:
3882
 
                        entry = basis_inv[file_id]
3883
 
                    except errors.NoSuchId:
3884
 
                        continue
3885
 
                    if entry.revision == file_revision:
3886
 
                        texts_possibly_new_in_tree.remove(file_key)
3887
 
            text_keys.update(texts_possibly_new_in_tree)
 
3780
                if new_path is not None:
 
3781
                    if not new_path:
 
3782
                        # This is the root
 
3783
                        if not self.target.supports_rich_root():
 
3784
                            # The target doesn't support rich root, so we don't
 
3785
                            # copy
 
3786
                            continue
 
3787
                        if self._converting_to_rich_root:
 
3788
                            # This can't be copied normally, we have to insert
 
3789
                            # it specially
 
3790
                            root_keys_to_create.add((file_id, entry.revision))
 
3791
                            continue
 
3792
                    text_keys.add((file_id, entry.revision))
 
3793
            revision = self.source.get_revision(current_revision_id)
 
3794
            pending_deltas.append((basis_id, delta,
 
3795
                current_revision_id, revision.parent_ids))
3888
3796
            pending_revisions.append(revision)
3889
3797
            cache[current_revision_id] = tree
3890
3798
            basis_id = current_revision_id
3891
 
        self.source._safe_to_return_from_cache = False
3892
3799
        # Copy file texts
3893
3800
        from_texts = self.source.texts
3894
3801
        to_texts = self.target.texts
3895
3802
        if root_keys_to_create:
3896
 
            root_stream = _mod_fetch._new_root_data_stream(
3897
 
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3898
 
                self.source, graph=a_graph)
 
3803
            root_stream = self._new_root_data_stream(root_keys_to_create,
 
3804
                                                     parent_map)
3899
3805
            to_texts.insert_record_stream(root_stream)
3900
3806
        to_texts.insert_record_stream(from_texts.get_record_stream(
3901
3807
            text_keys, self.target._format._fetch_order,
3923
3829
            for parent_tree in self.source.revision_trees(parent_map):
3924
3830
                current_revision_id = parent_tree.get_revision_id()
3925
3831
                parents_parents = parent_map[current_revision_id]
3926
 
                possible_trees = self._get_trees(parents_parents, cache)
3927
 
                if len(possible_trees) == 0:
3928
 
                    # There either aren't any parents, or the parents are
3929
 
                    # ghosts, so just use the last converted tree.
3930
 
                    possible_trees.append((basis_id, cache[basis_id]))
3931
3832
                basis_id, delta = self._get_delta_for_revision(parent_tree,
3932
 
                    parents_parents, possible_trees)
 
3833
                    parents_parents, basis_id, cache)
3933
3834
                self.target.add_inventory_by_delta(
3934
3835
                    basis_id, delta, current_revision_id, parents_parents)
3935
3836
        # insert signatures and revisions
3958
3859
        cache[basis_id] = basis_tree
3959
3860
        del basis_tree # We don't want to hang on to it here
3960
3861
        hints = []
3961
 
        if self._converting_to_rich_root and len(revision_ids) > 100:
3962
 
            a_graph = _mod_fetch._get_rich_root_heads_graph(self.source,
3963
 
                                                            revision_ids)
3964
 
        else:
3965
 
            a_graph = None
3966
 
 
3967
3862
        for offset in range(0, len(revision_ids), batch_size):
3968
3863
            self.target.start_write_group()
3969
3864
            try:
3970
3865
                pb.update('Transferring revisions', offset,
3971
3866
                          len(revision_ids))
3972
3867
                batch = revision_ids[offset:offset+batch_size]
3973
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
3974
 
                                             a_graph=a_graph)
 
3868
                basis_id = self._fetch_batch(batch, basis_id, cache)
3975
3869
            except:
3976
 
                self.source._safe_to_return_from_cache = False
3977
3870
                self.target.abort_write_group()
3978
3871
                raise
3979
3872
            else:
3991
3884
        """See InterRepository.fetch()."""
3992
3885
        if fetch_spec is not None:
3993
3886
            raise AssertionError("Not implemented yet...")
3994
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3995
3887
        if (not self.source.supports_rich_root()
3996
3888
            and self.target.supports_rich_root()):
3997
3889
            self._converting_to_rich_root = True
3998
3890
            self._revision_id_to_root_id = {}
3999
3891
        else:
4000
3892
            self._converting_to_rich_root = False
4001
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
4002
 
        if self.source._format.network_name() != self.target._format.network_name():
4003
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
4004
 
                from_format=self.source._format,
4005
 
                to_format=self.target._format)
4006
3893
        revision_ids = self.target.search_missing_revision_ids(self.source,
4007
3894
            revision_id, find_ghosts=find_ghosts).get_keys()
4008
3895
        if not revision_ids:
4014
3901
        # Walk though all revisions; get inventory deltas, copy referenced
4015
3902
        # texts that delta references, insert the delta, revision and
4016
3903
        # signature.
 
3904
        first_rev = self.source.get_revision(revision_ids[0])
4017
3905
        if pb is None:
4018
3906
            my_pb = ui.ui_factory.nested_progress_bar()
4019
3907
            pb = my_pb
4077
3965
        :param to_convert: The disk object to convert.
4078
3966
        :param pb: a progress bar to use for progress information.
4079
3967
        """
4080
 
        pb = ui.ui_factory.nested_progress_bar()
 
3968
        self.pb = pb
4081
3969
        self.count = 0
4082
3970
        self.total = 4
4083
3971
        # this is only useful with metadir layouts - separated repo content.
4084
3972
        # trigger an assertion if not such
4085
3973
        repo._format.get_format_string()
4086
3974
        self.repo_dir = repo.bzrdir
4087
 
        pb.update('Moving repository to repository.backup')
 
3975
        self.step('Moving repository to repository.backup')
4088
3976
        self.repo_dir.transport.move('repository', 'repository.backup')
4089
3977
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
4090
3978
        repo._format.check_conversion_target(self.target_format)
4091
3979
        self.source_repo = repo._format.open(self.repo_dir,
4092
3980
            _found=True,
4093
3981
            _override_transport=backup_transport)
4094
 
        pb.update('Creating new repository')
 
3982
        self.step('Creating new repository')
4095
3983
        converted = self.target_format.initialize(self.repo_dir,
4096
3984
                                                  self.source_repo.is_shared())
4097
3985
        converted.lock_write()
4098
3986
        try:
4099
 
            pb.update('Copying content')
 
3987
            self.step('Copying content into repository.')
4100
3988
            self.source_repo.copy_content_into(converted)
4101
3989
        finally:
4102
3990
            converted.unlock()
4103
 
        pb.update('Deleting old repository content')
 
3991
        self.step('Deleting old repository content.')
4104
3992
        self.repo_dir.transport.delete_tree('repository.backup')
4105
 
        ui.ui_factory.note('repository converted')
4106
 
        pb.finished()
 
3993
        self.pb.note('repository converted')
 
3994
 
 
3995
    def step(self, message):
 
3996
        """Update the pb by a step."""
 
3997
        self.count +=1
 
3998
        self.pb.update(message, self.count, self.total)
4107
3999
 
4108
4000
 
4109
4001
_unescape_map = {
4181
4073
        self.file_ids = set([file_id for file_id, _ in
4182
4074
            self.text_index.iterkeys()])
4183
4075
        # text keys is now grouped by file_id
 
4076
        n_weaves = len(self.file_ids)
 
4077
        files_in_revisions = {}
 
4078
        revisions_of_files = {}
4184
4079
        n_versions = len(self.text_index)
4185
4080
        progress_bar.update('loading text store', 0, n_versions)
4186
4081
        parent_map = self.repository.texts.get_parent_map(self.text_index)
4279
4174
            else:
4280
4175
                new_pack.set_write_cache_size(1024*1024)
4281
4176
        for substream_type, substream in stream:
4282
 
            if 'stream' in debug.debug_flags:
4283
 
                mutter('inserting substream: %s', substream_type)
4284
4177
            if substream_type == 'texts':
4285
4178
                self.target_repo.texts.insert_record_stream(substream)
4286
4179
            elif substream_type == 'inventories':
4290
4183
                else:
4291
4184
                    self._extract_and_insert_inventories(
4292
4185
                        substream, src_serializer)
4293
 
            elif substream_type == 'inventory-deltas':
4294
 
                self._extract_and_insert_inventory_deltas(
4295
 
                    substream, src_serializer)
4296
4186
            elif substream_type == 'chk_bytes':
4297
4187
                # XXX: This doesn't support conversions, as it assumes the
4298
4188
                #      conversion was done in the fetch code.
4329
4219
                ):
4330
4220
                if versioned_file is None:
4331
4221
                    continue
4332
 
                # TODO: key is often going to be a StaticTuple object
4333
 
                #       I don't believe we can define a method by which
4334
 
                #       (prefix,) + StaticTuple will work, though we could
4335
 
                #       define a StaticTuple.sq_concat that would allow you to
4336
 
                #       pass in either a tuple or a StaticTuple as the second
4337
 
                #       object, so instead we could have:
4338
 
                #       StaticTuple(prefix) + key here...
4339
4222
                missing_keys.update((prefix,) + key for key in
4340
4223
                    versioned_file.get_missing_compression_parent_keys())
4341
4224
        except NotImplementedError:
4356
4239
            self.target_repo.pack(hint=hint)
4357
4240
        return [], set()
4358
4241
 
4359
 
    def _extract_and_insert_inventory_deltas(self, substream, serializer):
4360
 
        target_rich_root = self.target_repo._format.rich_root_data
4361
 
        target_tree_refs = self.target_repo._format.supports_tree_reference
4362
 
        for record in substream:
4363
 
            # Insert the delta directly
4364
 
            inventory_delta_bytes = record.get_bytes_as('fulltext')
4365
 
            deserialiser = inventory_delta.InventoryDeltaDeserializer()
4366
 
            try:
4367
 
                parse_result = deserialiser.parse_text_bytes(
4368
 
                    inventory_delta_bytes)
4369
 
            except inventory_delta.IncompatibleInventoryDelta, err:
4370
 
                trace.mutter("Incompatible delta: %s", err.msg)
4371
 
                raise errors.IncompatibleRevision(self.target_repo._format)
4372
 
            basis_id, new_id, rich_root, tree_refs, inv_delta = parse_result
4373
 
            revision_id = new_id
4374
 
            parents = [key[0] for key in record.parents]
4375
 
            self.target_repo.add_inventory_by_delta(
4376
 
                basis_id, inv_delta, revision_id, parents)
4377
 
 
4378
 
    def _extract_and_insert_inventories(self, substream, serializer,
4379
 
            parse_delta=None):
 
4242
    def _extract_and_insert_inventories(self, substream, serializer):
4380
4243
        """Generate a new inventory versionedfile in target, converting data.
4381
4244
 
4382
4245
        The inventory is retrieved from the source, (deserializing it), and
4383
4246
        stored in the target (reserializing it in a different format).
4384
4247
        """
4385
 
        target_rich_root = self.target_repo._format.rich_root_data
4386
 
        target_tree_refs = self.target_repo._format.supports_tree_reference
4387
4248
        for record in substream:
4388
 
            # It's not a delta, so it must be a fulltext in the source
4389
 
            # serializer's format.
4390
4249
            bytes = record.get_bytes_as('fulltext')
4391
4250
            revision_id = record.key[0]
4392
4251
            inv = serializer.read_inventory_from_string(bytes, revision_id)
4393
4252
            parents = [key[0] for key in record.parents]
4394
4253
            self.target_repo.add_inventory(revision_id, inv, parents)
4395
 
            # No need to keep holding this full inv in memory when the rest of
4396
 
            # the substream is likely to be all deltas.
4397
 
            del inv
4398
4254
 
4399
4255
    def _extract_and_insert_revisions(self, substream, serializer):
4400
4256
        for record in substream:
4449
4305
        return [('signatures', signatures), ('revisions', revisions)]
4450
4306
 
4451
4307
    def _generate_root_texts(self, revs):
4452
 
        """This will be called by get_stream between fetching weave texts and
 
4308
        """This will be called by __fetch between fetching weave texts and
4453
4309
        fetching the inventory weave.
 
4310
 
 
4311
        Subclasses should override this if they need to generate root texts
 
4312
        after fetching weave texts.
4454
4313
        """
4455
4314
        if self._rich_root_upgrade():
4456
 
            return _mod_fetch.Inter1and2Helper(
 
4315
            import bzrlib.fetch
 
4316
            return bzrlib.fetch.Inter1and2Helper(
4457
4317
                self.from_repository).generate_root_texts(revs)
4458
4318
        else:
4459
4319
            return []
4462
4322
        phase = 'file'
4463
4323
        revs = search.get_keys()
4464
4324
        graph = self.from_repository.get_graph()
4465
 
        revs = tsort.topo_sort(graph.get_parent_map(revs))
 
4325
        revs = list(graph.iter_topo_order(revs))
4466
4326
        data_to_fetch = self.from_repository.item_keys_introduced_by(revs)
4467
4327
        text_keys = []
4468
4328
        for knit_kind, file_id, revisions in data_to_fetch:
4487
4347
                # will be valid.
4488
4348
                for _ in self._generate_root_texts(revs):
4489
4349
                    yield _
 
4350
                # NB: This currently reopens the inventory weave in source;
 
4351
                # using a single stream interface instead would avoid this.
 
4352
                from_weave = self.from_repository.inventories
4490
4353
                # we fetch only the referenced inventories because we do not
4491
4354
                # know for unselected inventories whether all their required
4492
4355
                # texts are present in the other repository - it could be
4531
4394
            if not keys:
4532
4395
                # No need to stream something we don't have
4533
4396
                continue
4534
 
            if substream_kind == 'inventories':
4535
 
                # Some missing keys are genuinely ghosts, filter those out.
4536
 
                present = self.from_repository.inventories.get_parent_map(keys)
4537
 
                revs = [key[0] for key in present]
4538
 
                # Get the inventory stream more-or-less as we do for the
4539
 
                # original stream; there's no reason to assume that records
4540
 
                # direct from the source will be suitable for the sink.  (Think
4541
 
                # e.g. 2a -> 1.9-rich-root).
4542
 
                for info in self._get_inventory_stream(revs, missing=True):
4543
 
                    yield info
4544
 
                continue
4545
 
 
4546
4397
            # Ask for full texts always so that we don't need more round trips
4547
4398
            # after this stream.
4548
4399
            # Some of the missing keys are genuinely ghosts, so filter absent
4563
4414
        return (not self.from_repository._format.rich_root_data and
4564
4415
            self.to_format.rich_root_data)
4565
4416
 
4566
 
    def _get_inventory_stream(self, revision_ids, missing=False):
 
4417
    def _get_inventory_stream(self, revision_ids):
4567
4418
        from_format = self.from_repository._format
4568
 
        if (from_format.supports_chks and self.to_format.supports_chks and
4569
 
            from_format.network_name() == self.to_format.network_name()):
4570
 
            raise AssertionError(
4571
 
                "this case should be handled by GroupCHKStreamSource")
4572
 
        elif 'forceinvdeltas' in debug.debug_flags:
4573
 
            return self._get_convertable_inventory_stream(revision_ids,
4574
 
                    delta_versus_null=missing)
4575
 
        elif from_format.network_name() == self.to_format.network_name():
4576
 
            # Same format.
4577
 
            return self._get_simple_inventory_stream(revision_ids,
4578
 
                    missing=missing)
4579
 
        elif (not from_format.supports_chks and not self.to_format.supports_chks
4580
 
                and from_format._serializer == self.to_format._serializer):
4581
 
            # Essentially the same format.
4582
 
            return self._get_simple_inventory_stream(revision_ids,
4583
 
                    missing=missing)
 
4419
        if (from_format.supports_chks and self.to_format.supports_chks
 
4420
            and (from_format._serializer == self.to_format._serializer)):
 
4421
            # Both sides support chks, and they use the same serializer, so it
 
4422
            # is safe to transmit the chk pages and inventory pages across
 
4423
            # as-is.
 
4424
            return self._get_chk_inventory_stream(revision_ids)
 
4425
        elif (not from_format.supports_chks):
 
4426
            # Source repository doesn't support chks. So we can transmit the
 
4427
            # inventories 'as-is' and either they are just accepted on the
 
4428
            # target, or the Sink will properly convert it.
 
4429
            return self._get_simple_inventory_stream(revision_ids)
4584
4430
        else:
4585
 
            # Any time we switch serializations, we want to use an
4586
 
            # inventory-delta based approach.
4587
 
            return self._get_convertable_inventory_stream(revision_ids,
4588
 
                    delta_versus_null=missing)
 
4431
            # XXX: Hack to make not-chk->chk fetch: copy the inventories as
 
4432
            #      inventories. Note that this should probably be done somehow
 
4433
            #      as part of bzrlib.repository.StreamSink. Except JAM couldn't
 
4434
            #      figure out how a non-chk repository could possibly handle
 
4435
            #      deserializing an inventory stream from a chk repo, as it
 
4436
            #      doesn't have a way to understand individual pages.
 
4437
            return self._get_convertable_inventory_stream(revision_ids)
4589
4438
 
4590
 
    def _get_simple_inventory_stream(self, revision_ids, missing=False):
4591
 
        # NB: This currently reopens the inventory weave in source;
4592
 
        # using a single stream interface instead would avoid this.
 
4439
    def _get_simple_inventory_stream(self, revision_ids):
4593
4440
        from_weave = self.from_repository.inventories
4594
 
        if missing:
4595
 
            delta_closure = True
4596
 
        else:
4597
 
            delta_closure = not self.delta_on_metadata()
4598
4441
        yield ('inventories', from_weave.get_record_stream(
4599
4442
            [(rev_id,) for rev_id in revision_ids],
4600
 
            self.inventory_fetch_order(), delta_closure))
4601
 
 
4602
 
    def _get_convertable_inventory_stream(self, revision_ids,
4603
 
                                          delta_versus_null=False):
4604
 
        # The two formats are sufficiently different that there is no fast
4605
 
        # path, so we need to send just inventorydeltas, which any
4606
 
        # sufficiently modern client can insert into any repository.
4607
 
        # The StreamSink code expects to be able to
4608
 
        # convert on the target, so we need to put bytes-on-the-wire that can
4609
 
        # be converted.  That means inventory deltas (if the remote is <1.19,
4610
 
        # RemoteStreamSink will fallback to VFS to insert the deltas).
4611
 
        yield ('inventory-deltas',
4612
 
           self._stream_invs_as_deltas(revision_ids,
4613
 
                                       delta_versus_null=delta_versus_null))
4614
 
 
4615
 
    def _stream_invs_as_deltas(self, revision_ids, delta_versus_null=False):
4616
 
        """Return a stream of inventory-deltas for the given rev ids.
4617
 
 
4618
 
        :param revision_ids: The list of inventories to transmit
4619
 
        :param delta_versus_null: Don't try to find a minimal delta for this
4620
 
            entry, instead compute the delta versus the NULL_REVISION. This
4621
 
            effectively streams a complete inventory. Used for stuff like
4622
 
            filling in missing parents, etc.
4623
 
        """
 
4443
            self.inventory_fetch_order(),
 
4444
            not self.delta_on_metadata()))
 
4445
 
 
4446
    def _get_chk_inventory_stream(self, revision_ids):
 
4447
        """Fetch the inventory texts, along with the associated chk maps."""
 
4448
        # We want an inventory outside of the search set, so that we can filter
 
4449
        # out uninteresting chk pages. For now we use
 
4450
        # _find_revision_outside_set, but if we had a Search with cut_revs, we
 
4451
        # could use that instead.
 
4452
        start_rev_id = self.from_repository._find_revision_outside_set(
 
4453
                            revision_ids)
 
4454
        start_rev_key = (start_rev_id,)
 
4455
        inv_keys_to_fetch = [(rev_id,) for rev_id in revision_ids]
 
4456
        if start_rev_id != _mod_revision.NULL_REVISION:
 
4457
            inv_keys_to_fetch.append((start_rev_id,))
 
4458
        # Any repo that supports chk_bytes must also support out-of-order
 
4459
        # insertion. At least, that is how we expect it to work
 
4460
        # We use get_record_stream instead of iter_inventories because we want
 
4461
        # to be able to insert the stream as well. We could instead fetch
 
4462
        # allowing deltas, and then iter_inventories, but we don't know whether
 
4463
        # source or target is more 'local' anway.
 
4464
        inv_stream = self.from_repository.inventories.get_record_stream(
 
4465
            inv_keys_to_fetch, 'unordered',
 
4466
            True) # We need them as full-texts so we can find their references
 
4467
        uninteresting_chk_roots = set()
 
4468
        interesting_chk_roots = set()
 
4469
        def filter_inv_stream(inv_stream):
 
4470
            for idx, record in enumerate(inv_stream):
 
4471
                ### child_pb.update('fetch inv', idx, len(inv_keys_to_fetch))
 
4472
                bytes = record.get_bytes_as('fulltext')
 
4473
                chk_inv = inventory.CHKInventory.deserialise(
 
4474
                    self.from_repository.chk_bytes, bytes, record.key)
 
4475
                if record.key == start_rev_key:
 
4476
                    uninteresting_chk_roots.add(chk_inv.id_to_entry.key())
 
4477
                    p_id_map = chk_inv.parent_id_basename_to_file_id
 
4478
                    if p_id_map is not None:
 
4479
                        uninteresting_chk_roots.add(p_id_map.key())
 
4480
                else:
 
4481
                    yield record
 
4482
                    interesting_chk_roots.add(chk_inv.id_to_entry.key())
 
4483
                    p_id_map = chk_inv.parent_id_basename_to_file_id
 
4484
                    if p_id_map is not None:
 
4485
                        interesting_chk_roots.add(p_id_map.key())
 
4486
        ### pb.update('fetch inventory', 0, 2)
 
4487
        yield ('inventories', filter_inv_stream(inv_stream))
 
4488
        # Now that we have worked out all of the interesting root nodes, grab
 
4489
        # all of the interesting pages and insert them
 
4490
        ### pb.update('fetch inventory', 1, 2)
 
4491
        interesting = chk_map.iter_interesting_nodes(
 
4492
            self.from_repository.chk_bytes, interesting_chk_roots,
 
4493
            uninteresting_chk_roots)
 
4494
        def to_stream_adapter():
 
4495
            """Adapt the iter_interesting_nodes result to a single stream.
 
4496
 
 
4497
            iter_interesting_nodes returns records as it processes them, along
 
4498
            with keys. However, we only want to return the records themselves.
 
4499
            """
 
4500
            for record, items in interesting:
 
4501
                if record is not None:
 
4502
                    yield record
 
4503
        # XXX: We could instead call get_record_stream(records.keys())
 
4504
        #      ATM, this will always insert the records as fulltexts, and
 
4505
        #      requires that you can hang on to records once you have gone
 
4506
        #      on to the next one. Further, it causes the target to
 
4507
        #      recompress the data. Testing shows it to be faster than
 
4508
        #      requesting the records again, though.
 
4509
        yield ('chk_bytes', to_stream_adapter())
 
4510
        ### pb.update('fetch inventory', 2, 2)
 
4511
 
 
4512
    def _get_convertable_inventory_stream(self, revision_ids):
 
4513
        # XXX: One of source or target is using chks, and they don't have
 
4514
        #      compatible serializations. The StreamSink code expects to be
 
4515
        #      able to convert on the target, so we need to put
 
4516
        #      bytes-on-the-wire that can be converted
 
4517
        yield ('inventories', self._stream_invs_as_fulltexts(revision_ids))
 
4518
 
 
4519
    def _stream_invs_as_fulltexts(self, revision_ids):
4624
4520
        from_repo = self.from_repository
 
4521
        from_serializer = from_repo._format._serializer
4625
4522
        revision_keys = [(rev_id,) for rev_id in revision_ids]
4626
4523
        parent_map = from_repo.inventories.get_parent_map(revision_keys)
4627
 
        # XXX: possibly repos could implement a more efficient iter_inv_deltas
4628
 
        # method...
4629
 
        inventories = self.from_repository.iter_inventories(
4630
 
            revision_ids, 'topological')
4631
 
        format = from_repo._format
4632
 
        invs_sent_so_far = set([_mod_revision.NULL_REVISION])
4633
 
        inventory_cache = lru_cache.LRUCache(50)
4634
 
        null_inventory = from_repo.revision_tree(
4635
 
            _mod_revision.NULL_REVISION).inventory
4636
 
        # XXX: ideally the rich-root/tree-refs flags would be per-revision, not
4637
 
        # per-repo (e.g.  streaming a non-rich-root revision out of a rich-root
4638
 
        # repo back into a non-rich-root repo ought to be allowed)
4639
 
        serializer = inventory_delta.InventoryDeltaSerializer(
4640
 
            versioned_root=format.rich_root_data,
4641
 
            tree_references=format.supports_tree_reference)
4642
 
        for inv in inventories:
 
4524
        for inv in self.from_repository.iter_inventories(revision_ids):
 
4525
            # XXX: This is a bit hackish, but it works. Basically,
 
4526
            #      CHKSerializer 'accidentally' supports
 
4527
            #      read/write_inventory_to_string, even though that is never
 
4528
            #      the format that is stored on disk. It *does* give us a
 
4529
            #      single string representation for an inventory, so live with
 
4530
            #      it for now.
 
4531
            #      This would be far better if we had a 'serialized inventory
 
4532
            #      delta' form. Then we could use 'inventory._make_delta', and
 
4533
            #      transmit that. This would both be faster to generate, and
 
4534
            #      result in fewer bytes-on-the-wire.
 
4535
            as_bytes = from_serializer.write_inventory_to_string(inv)
4643
4536
            key = (inv.revision_id,)
4644
4537
            parent_keys = parent_map.get(key, ())
4645
 
            delta = None
4646
 
            if not delta_versus_null and parent_keys:
4647
 
                # The caller did not ask for complete inventories and we have
4648
 
                # some parents that we can delta against.  Make a delta against
4649
 
                # each parent so that we can find the smallest.
4650
 
                parent_ids = [parent_key[0] for parent_key in parent_keys]
4651
 
                for parent_id in parent_ids:
4652
 
                    if parent_id not in invs_sent_so_far:
4653
 
                        # We don't know that the remote side has this basis, so
4654
 
                        # we can't use it.
4655
 
                        continue
4656
 
                    if parent_id == _mod_revision.NULL_REVISION:
4657
 
                        parent_inv = null_inventory
4658
 
                    else:
4659
 
                        parent_inv = inventory_cache.get(parent_id, None)
4660
 
                        if parent_inv is None:
4661
 
                            parent_inv = from_repo.get_inventory(parent_id)
4662
 
                    candidate_delta = inv._make_delta(parent_inv)
4663
 
                    if (delta is None or
4664
 
                        len(delta) > len(candidate_delta)):
4665
 
                        delta = candidate_delta
4666
 
                        basis_id = parent_id
4667
 
            if delta is None:
4668
 
                # Either none of the parents ended up being suitable, or we
4669
 
                # were asked to delta against NULL
4670
 
                basis_id = _mod_revision.NULL_REVISION
4671
 
                delta = inv._make_delta(null_inventory)
4672
 
            invs_sent_so_far.add(inv.revision_id)
4673
 
            inventory_cache[inv.revision_id] = inv
4674
 
            delta_serialized = ''.join(
4675
 
                serializer.delta_to_lines(basis_id, key[-1], delta))
4676
4538
            yield versionedfile.FulltextContentFactory(
4677
 
                key, parent_keys, None, delta_serialized)
 
4539
                key, parent_keys, None, as_bytes)
4678
4540
 
4679
4541
 
4680
4542
def _iter_for_revno(repo, partial_history_cache, stop_index=None,