/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: Andrew Bennetts
  • Date: 2009-08-13 00:20:29 UTC
  • mto: This revision was merged to the branch mainline in revision 4608.
  • Revision ID: andrew.bennetts@canonical.com-20090813002029-akc5x2mtxa8rq068
Raise InventoryDeltaErrors, not generic BzrErrors, from inventory_delta.py.

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,
40
38
    lru_cache,
41
39
    osutils,
42
40
    revision as _mod_revision,
43
 
    static_tuple,
44
41
    symbol_versioning,
45
 
    trace,
46
42
    tsort,
47
43
    ui,
48
44
    versionedfile,
53
49
from bzrlib.testament import Testament
54
50
""")
55
51
 
56
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
52
from bzrlib.decorators import needs_read_lock, needs_write_lock
57
53
from bzrlib.inter import InterObject
58
54
from bzrlib.inventory import (
59
55
    Inventory,
61
57
    ROOT_ID,
62
58
    entry_factory,
63
59
    )
64
 
from bzrlib.lock import _RelockDebugMixin
65
60
from bzrlib import registry
66
61
from bzrlib.trace import (
67
62
    log_exception_quietly, note, mutter, mutter_callsite, warning)
210
205
            # an inventory delta was accumulated without creating a new
211
206
            # inventory.
212
207
            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(
 
208
            self.inv_sha1 = self.repository.add_inventory_by_delta(
217
209
                basis_id, self._basis_delta, self._new_revision_id,
218
210
                self.parents)
219
211
        else:
473
465
            if content_summary[2] is None:
474
466
                raise ValueError("Files must not have executable = None")
475
467
            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:
 
468
                if (# if the file length changed we have to store:
 
469
                    parent_entry.text_size != content_summary[1] or
 
470
                    # if the exec bit has changed we have to store:
479
471
                    parent_entry.executable != content_summary[2]):
480
472
                    store = True
481
473
                elif parent_entry.text_sha1 == content_summary[3]:
548
540
                ie.revision = parent_entry.revision
549
541
                return self._get_delta(ie, basis_inv, path), False, None
550
542
            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
543
            self._add_text_to_weave(ie.file_id, '', heads, None)
555
544
        else:
556
545
            raise NotImplementedError('unknown kind')
818
807
                seen_root = True
819
808
        self.new_inventory = None
820
809
        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
810
            self._any_changes = True
825
811
        if not seen_root:
826
812
            # housekeeping root entry changes do not affect no-change commits.
864
850
# Repositories
865
851
 
866
852
 
867
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
853
class Repository(object):
868
854
    """Repository holding history for one or more branches.
869
855
 
870
856
    The repository holds and retrieves historical information including
1028
1014
 
1029
1015
        :seealso: add_inventory, for the contract.
1030
1016
        """
1031
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1017
        inv_lines = self._serialise_inventory_to_lines(inv)
1032
1018
        return self._inventory_add_lines(revision_id, parents,
1033
1019
            inv_lines, check_content=False)
1034
1020
 
1230
1216
                    for record in getattr(self, kind).check(keys=keys[kind]):
1231
1217
                        if record.storage_kind == 'absent':
1232
1218
                            checker._report_items.append(
1233
 
                                'Missing %s {%s}' % (kind, record.key,))
 
1219
                                'Missing inventory {%s}' % (record.key,))
1234
1220
                        else:
1235
1221
                            last_object = self._check_record(kind, record,
1236
1222
                                checker, last_object, current_keys[(kind,) + record.key])
1241
1227
        """Check a single text from this repository."""
1242
1228
        if kind == 'inventories':
1243
1229
            rev_id = record.key[0]
1244
 
            inv = self._deserialise_inventory(rev_id,
 
1230
            inv = self.deserialise_inventory(rev_id,
1245
1231
                record.get_bytes_as('fulltext'))
1246
1232
            if last_object is not None:
1247
1233
                delta = inv._make_delta(last_object)
1291
1277
 
1292
1278
        :param _format: The format of the repository on disk.
1293
1279
        :param a_bzrdir: The BzrDir of the repository.
 
1280
 
 
1281
        In the future we will have a single api for all stores for
 
1282
        getting file texts, inventories and revisions, then
 
1283
        this construct will accept instances of those things.
1294
1284
        """
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
1285
        super(Repository, self).__init__()
1299
1286
        self._format = _format
1300
1287
        # the following are part of the public API for Repository:
1306
1293
        self._reconcile_does_inventory_gc = True
1307
1294
        self._reconcile_fixes_text_parents = False
1308
1295
        self._reconcile_backsup_inventory = True
 
1296
        # not right yet - should be more semantically clear ?
 
1297
        #
 
1298
        # TODO: make sure to construct the right store classes, etc, depending
 
1299
        # on whether escaping is required.
 
1300
        self._warn_if_deprecated()
1309
1301
        self._write_group = None
1310
1302
        # Additional places to query for data.
1311
1303
        self._fallback_repositories = []
1312
1304
        # An InventoryEntry cache, used during deserialization
1313
1305
        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
1306
 
1326
1307
    def __repr__(self):
1327
1308
        if self._fallback_repositories:
1394
1375
        locked = self.is_locked()
1395
1376
        result = self.control_files.lock_write(token=token)
1396
1377
        if not locked:
1397
 
            self._warn_if_deprecated()
1398
 
            self._note_lock('w')
1399
1378
            for repo in self._fallback_repositories:
1400
1379
                # Writes don't affect fallback repos
1401
1380
                repo.lock_read()
1406
1385
        locked = self.is_locked()
1407
1386
        self.control_files.lock_read()
1408
1387
        if not locked:
1409
 
            self._warn_if_deprecated()
1410
 
            self._note_lock('r')
1411
1388
            for repo in self._fallback_repositories:
1412
1389
                repo.lock_read()
1413
1390
            self._refresh_data()
1476
1453
 
1477
1454
        # now gather global repository information
1478
1455
        # XXX: This is available for many repos regardless of listability.
1479
 
        if self.user_transport.listable():
 
1456
        if self.bzrdir.root_transport.listable():
1480
1457
            # XXX: do we want to __define len__() ?
1481
1458
            # Maybe the versionedfiles object should provide a different
1482
1459
            # method to get the number of keys.
1492
1469
        :param using: If True, list only branches using this repository.
1493
1470
        """
1494
1471
        if using and not self.is_shared():
1495
 
            return self.bzrdir.list_branches()
 
1472
            try:
 
1473
                return [self.bzrdir.open_branch()]
 
1474
            except errors.NotBranchError:
 
1475
                return []
1496
1476
        class Evaluator(object):
1497
1477
 
1498
1478
            def __init__(self):
1507
1487
                    except errors.NoRepositoryPresent:
1508
1488
                        pass
1509
1489
                    else:
1510
 
                        return False, ([], repository)
 
1490
                        return False, (None, repository)
1511
1491
                self.first_call = False
1512
 
                value = (bzrdir.list_branches(), None)
 
1492
                try:
 
1493
                    value = (bzrdir.open_branch(), None)
 
1494
                except errors.NotBranchError:
 
1495
                    value = (None, None)
1513
1496
                return True, value
1514
1497
 
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)
 
1498
        branches = []
 
1499
        for branch, repository in bzrdir.BzrDir.find_bzrdirs(
 
1500
                self.bzrdir.root_transport, evaluate=Evaluator()):
 
1501
            if branch is not None:
 
1502
                branches.append(branch)
1520
1503
            if not using and repository is not None:
1521
 
                ret.extend(repository.find_branches())
1522
 
        return ret
 
1504
                branches.extend(repository.find_branches())
 
1505
        return branches
1523
1506
 
1524
1507
    @needs_read_lock
1525
1508
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1615
1598
        # but at the moment we're only checking for texts referenced by
1616
1599
        # inventories at the graph's edge.
1617
1600
        key_deps = self.revisions._index._key_dependencies
1618
 
        key_deps.satisfy_refs_for_keys(present_inventories)
 
1601
        key_deps.add_keys(present_inventories)
1619
1602
        referrers = frozenset(r[0] for r in key_deps.get_referrers())
1620
1603
        file_ids = self.fileids_altered_by_revision_ids(referrers)
1621
1604
        missing_texts = set()
1722
1705
        :param revprops: Optional dictionary of revision properties.
1723
1706
        :param revision_id: Optional revision id.
1724
1707
        """
1725
 
        if self._fallback_repositories:
1726
 
            raise errors.BzrError("Cannot commit from a lightweight checkout "
1727
 
                "to a stacked branch. See "
1728
 
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
1729
1708
        result = self._commit_builder_class(self, parents, config,
1730
1709
            timestamp, timezone, committer, revprops, revision_id)
1731
1710
        self.start_write_group()
1732
1711
        return result
1733
1712
 
1734
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1735
1713
    def unlock(self):
1736
1714
        if (self.control_files._lock_count == 1 and
1737
1715
            self.control_files._lock_mode == 'w'):
1903
1881
                rev = self._serializer.read_revision_from_string(text)
1904
1882
                yield (revid, rev)
1905
1883
 
 
1884
    @needs_read_lock
 
1885
    def get_revision_xml(self, revision_id):
 
1886
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1887
        #       would have already do it.
 
1888
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1889
        # TODO: this can't just be replaced by:
 
1890
        # return self._serializer.write_revision_to_string(
 
1891
        #     self.get_revision(revision_id))
 
1892
        # as cStringIO preservers the encoding unlike write_revision_to_string
 
1893
        # or some other call down the path.
 
1894
        rev = self.get_revision(revision_id)
 
1895
        rev_tmp = cStringIO.StringIO()
 
1896
        # the current serializer..
 
1897
        self._serializer.write_revision(rev, rev_tmp)
 
1898
        rev_tmp.seek(0)
 
1899
        return rev_tmp.getvalue()
 
1900
 
1906
1901
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1907
1902
        """Produce a generator of revision deltas.
1908
1903
 
2150
2145
        """
2151
2146
        selected_keys = set((revid,) for revid in revision_ids)
2152
2147
        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)
 
2148
        pb = ui.ui_factory.nested_progress_bar()
 
2149
        try:
 
2150
            return self._find_file_ids_from_xml_inventory_lines(
 
2151
                w.iter_lines_added_or_present_in_keys(
 
2152
                    selected_keys, pb=pb),
 
2153
                selected_keys)
 
2154
        finally:
 
2155
            pb.finished()
2157
2156
 
2158
2157
    def iter_files_bytes(self, desired_files):
2159
2158
        """Iterate through file versions.
2320
2319
        num_file_ids = len(file_ids)
2321
2320
        for file_id, altered_versions in file_ids.iteritems():
2322
2321
            if pb is not None:
2323
 
                pb.update("Fetch texts", count, num_file_ids)
 
2322
                pb.update("fetch texts", count, num_file_ids)
2324
2323
            count += 1
2325
2324
            yield ("file", file_id, altered_versions)
2326
2325
 
2369
2368
        """single-document based inventory iteration."""
2370
2369
        inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2371
2370
        for text, revision_id in inv_xmls:
2372
 
            yield self._deserialise_inventory(revision_id, text)
 
2371
            yield self.deserialise_inventory(revision_id, text)
2373
2372
 
2374
2373
    def _iter_inventory_xmls(self, revision_ids, ordering):
2375
2374
        if ordering is None:
2407
2406
                        next_key = None
2408
2407
                        break
2409
2408
 
2410
 
    def _deserialise_inventory(self, revision_id, xml):
 
2409
    def deserialise_inventory(self, revision_id, xml):
2411
2410
        """Transform the xml into an inventory object.
2412
2411
 
2413
2412
        :param revision_id: The expected revision id of the inventory.
2414
2413
        :param xml: A serialised inventory.
2415
2414
        """
2416
2415
        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)
 
2416
                    entry_cache=self._inventory_entry_cache)
2419
2417
        if result.revision_id != revision_id:
2420
2418
            raise AssertionError('revision id mismatch %s != %s' % (
2421
2419
                result.revision_id, revision_id))
2422
2420
        return result
2423
2421
 
 
2422
    def serialise_inventory(self, inv):
 
2423
        return self._serializer.write_inventory_to_string(inv)
 
2424
 
 
2425
    def _serialise_inventory_to_lines(self, inv):
 
2426
        return self._serializer.write_inventory_to_lines(inv)
 
2427
 
2424
2428
    def get_serializer_format(self):
2425
2429
        return self._serializer.format_num
2426
2430
 
2427
2431
    @needs_read_lock
2428
 
    def _get_inventory_xml(self, revision_id):
2429
 
        """Get serialized inventory as a string."""
 
2432
    def get_inventory_xml(self, revision_id):
 
2433
        """Get inventory XML as a file object."""
2430
2434
        texts = self._iter_inventory_xmls([revision_id], 'unordered')
2431
2435
        try:
2432
2436
            text, revision_id = texts.next()
2434
2438
            raise errors.HistoryMissing(self, 'inventory', revision_id)
2435
2439
        return text
2436
2440
 
 
2441
    @needs_read_lock
 
2442
    def get_inventory_sha1(self, revision_id):
 
2443
        """Return the sha1 hash of the inventory entry
 
2444
        """
 
2445
        return self.get_revision(revision_id).inventory_sha1
 
2446
 
2437
2447
    def get_rev_id_for_revno(self, revno, known_pair):
2438
2448
        """Return the revision id of a revno, given a later (revno, revid)
2439
2449
        pair in the same history.
2490
2500
            else:
2491
2501
                next_id = parents[0]
2492
2502
 
 
2503
    @needs_read_lock
 
2504
    def get_revision_inventory(self, revision_id):
 
2505
        """Return inventory of a past revision."""
 
2506
        # TODO: Unify this with get_inventory()
 
2507
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
2508
        # must be the same as its revision, so this is trivial.
 
2509
        if revision_id is None:
 
2510
            # This does not make sense: if there is no revision,
 
2511
            # then it is the current tree inventory surely ?!
 
2512
            # and thus get_root_id() is something that looks at the last
 
2513
            # commit on the branch, and the get_root_id is an inventory check.
 
2514
            raise NotImplementedError
 
2515
            # return Inventory(self.get_root_id())
 
2516
        else:
 
2517
            return self.get_inventory(revision_id)
 
2518
 
2493
2519
    def is_shared(self):
2494
2520
        """Return True if this repository is flagged as a shared repository."""
2495
2521
        raise NotImplementedError(self.is_shared)
2529
2555
            return RevisionTree(self, Inventory(root_id=None),
2530
2556
                                _mod_revision.NULL_REVISION)
2531
2557
        else:
2532
 
            inv = self.get_inventory(revision_id)
 
2558
            inv = self.get_revision_inventory(revision_id)
2533
2559
            return RevisionTree(self, inv, revision_id)
2534
2560
 
2535
2561
    def revision_trees(self, revision_ids):
2588
2614
            keys = tsort.topo_sort(parent_map)
2589
2615
        return [None] + list(keys)
2590
2616
 
2591
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2617
    def pack(self, hint=None):
2592
2618
        """Compress the data within the repository.
2593
2619
 
2594
2620
        This operation only makes sense for some repository types. For other
2604
2630
            obtained from the result of commit_write_group(). Out of
2605
2631
            date hints are simply ignored, because concurrent operations
2606
2632
            can obsolete them rapidly.
2607
 
 
2608
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2609
 
            the pack operation.
2610
2633
        """
2611
2634
 
2612
2635
    def get_transaction(self):
2628
2651
        for ((revision_id,), parent_keys) in \
2629
2652
                self.revisions.get_parent_map(query_keys).iteritems():
2630
2653
            if parent_keys:
2631
 
                result[revision_id] = tuple([parent_revid
2632
 
                    for (parent_revid,) in parent_keys])
 
2654
                result[revision_id] = tuple(parent_revid
 
2655
                    for (parent_revid,) in parent_keys)
2633
2656
            else:
2634
2657
                result[revision_id] = (_mod_revision.NULL_REVISION,)
2635
2658
        return result
2637
2660
    def _make_parents_provider(self):
2638
2661
        return self
2639
2662
 
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
2663
    def get_graph(self, other_repository=None):
2650
2664
        """Return the graph walker for this repository format"""
2651
2665
        parents_provider = self._make_parents_provider()
2746
2760
        result.check(callback_refs)
2747
2761
        return result
2748
2762
 
2749
 
    def _warn_if_deprecated(self, branch=None):
 
2763
    def _warn_if_deprecated(self):
2750
2764
        global _deprecation_warning_done
2751
2765
        if _deprecation_warning_done:
2752
2766
            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
 
2767
        _deprecation_warning_done = True
 
2768
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
2769
                % (self._format, self.bzrdir.transport.base))
2765
2770
 
2766
2771
    def supports_rich_root(self):
2767
2772
        return self._format.rich_root_data
3048
3053
    # help), and for fetching when data won't have come from the same
3049
3054
    # compressor.
3050
3055
    pack_compresses = False
3051
 
    # Does the repository inventory storage understand references to trees?
3052
 
    supports_tree_reference = None
3053
 
    # Is the format experimental ?
3054
 
    experimental = False
3055
3056
 
3056
 
    def __repr__(self):
3057
 
        return "%s()" % self.__class__.__name__
 
3057
    def __str__(self):
 
3058
        return "<%s>" % self.__class__.__name__
3058
3059
 
3059
3060
    def __eq__(self, other):
3060
3061
        # format objects are generally stateless
3073
3074
        """
3074
3075
        try:
3075
3076
            transport = a_bzrdir.get_repository_transport(None)
3076
 
            format_string = transport.get_bytes("format")
 
3077
            format_string = transport.get("format").read()
3077
3078
            return format_registry.get(format_string)
3078
3079
        except errors.NoSuchFile:
3079
3080
            raise errors.NoRepositoryPresent(a_bzrdir)
3161
3162
        raise NotImplementedError(self.network_name)
3162
3163
 
3163
3164
    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)
 
3165
        raise NotImplementedError(self.check_conversion_target)
3173
3166
 
3174
3167
    def open(self, a_bzrdir, _found=False):
3175
3168
        """Return an instance of this format for the bzrdir a_bzrdir.
3178
3171
        """
3179
3172
        raise NotImplementedError(self.open)
3180
3173
 
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
3174
 
3191
3175
class MetaDirRepositoryFormat(RepositoryFormat):
3192
3176
    """Common base class for the new repositories using the metadir layout."""
3397
3381
 
3398
3382
        :param revision_id: if None all content is copied, if NULL_REVISION no
3399
3383
                            content is copied.
3400
 
        :param pb: ignored.
 
3384
        :param pb: optional progress bar to use for progress reports. If not
 
3385
                   provided a default one will be created.
3401
3386
        :return: None.
3402
3387
        """
3403
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3404
3388
        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
3389
        f = RepoFetcher(to_repository=self.target,
3411
3390
                               from_repository=self.source,
3412
3391
                               last_revision=revision_id,
3413
3392
                               fetch_spec=fetch_spec,
3414
 
                               find_ghosts=find_ghosts)
 
3393
                               pb=pb, find_ghosts=find_ghosts)
3415
3394
 
3416
3395
    def _walk_to_common_revisions(self, revision_ids):
3417
3396
        """Walk out from revision_ids in source to revisions target has.
3586
3565
                self.target.texts.insert_record_stream(
3587
3566
                    self.source.texts.get_record_stream(
3588
3567
                        self.source.texts.keys(), 'topological', False))
3589
 
                pb.update('Copying inventory', 0, 1)
 
3568
                pb.update('copying inventory', 0, 1)
3590
3569
                self.target.inventories.insert_record_stream(
3591
3570
                    self.source.inventories.get_record_stream(
3592
3571
                        self.source.inventories.keys(), 'topological', False))
3718
3697
        # This is redundant with format.check_conversion_target(), however that
3719
3698
        # raises an exception, and we just want to say "False" as in we won't
3720
3699
        # support converting between these formats.
3721
 
        if 'IDS_never' in debug.debug_flags:
 
3700
        if 'IDS:never' in debug.debug_flags:
3722
3701
            return False
3723
3702
        if source.supports_rich_root() and not target.supports_rich_root():
3724
3703
            return False
3729
3708
            # IDS doesn't know how to copy CHKs for the parent inventories it
3730
3709
            # adds to stacked repos.
3731
3710
            return False
3732
 
        if 'IDS_always' in debug.debug_flags:
 
3711
        if 'IDS:always' in debug.debug_flags:
3733
3712
            return True
3734
3713
        # Only use this code path for local source and target.  IDS does far
3735
3714
        # too much IO (both bandwidth and roundtrips) over a network.
3739
3718
            return False
3740
3719
        return True
3741
3720
 
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):
 
3721
    def _get_delta_for_revision(self, tree, parent_ids, basis_id, cache):
3760
3722
        """Get the best delta and base for this revision.
3761
3723
 
3762
3724
        :return: (basis_id, delta)
3763
3725
        """
 
3726
        possible_trees = [(parent_id, cache[parent_id])
 
3727
                          for parent_id in parent_ids
 
3728
                           if parent_id in cache]
 
3729
        if len(possible_trees) == 0:
 
3730
            # There either aren't any parents, or the parents aren't in the
 
3731
            # cache, so just use the last converted tree
 
3732
            possible_trees.append((basis_id, cache[basis_id]))
3764
3733
        deltas = []
3765
 
        # Generate deltas against each tree, to find the shortest.
3766
 
        texts_possibly_new_in_tree = set()
3767
3734
        for basis_id, basis_tree in possible_trees:
3768
3735
            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
3736
            deltas.append((len(delta), basis_id, delta))
3784
3737
        deltas.sort()
3785
3738
        return deltas[0][1:]
3786
3739
 
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):
 
3740
    def _fetch_batch(self, revision_ids, basis_id, cache):
3817
3741
        """Fetch across a few revisions.
3818
3742
 
3819
3743
        :param revision_ids: The revisions to copy
3820
3744
        :param basis_id: The revision_id of a tree that must be in cache, used
3821
3745
            as a basis for delta when no other base is available
3822
3746
        :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
3747
        :return: The revision_id of the last converted tree. The RevisionTree
3826
3748
            for it will be in cache
3827
3749
        """
3833
3755
        pending_deltas = []
3834
3756
        pending_revisions = []
3835
3757
        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
3758
        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
3759
            current_revision_id = tree.get_revision_id()
3842
3760
            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
3761
            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))
 
3762
                                                           basis_id, cache)
3854
3763
            if self._converting_to_rich_root:
3855
3764
                self._revision_id_to_root_id[current_revision_id] = \
3856
3765
                    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()
 
3766
            # Find text entries that need to be copied
3860
3767
            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)
 
3768
                if new_path is not None:
 
3769
                    if not new_path:
 
3770
                        # This is the root
 
3771
                        if not self.target.supports_rich_root():
 
3772
                            # The target doesn't support rich root, so we don't
 
3773
                            # copy
 
3774
                            continue
 
3775
                        if self._converting_to_rich_root:
 
3776
                            # This can't be copied normally, we have to insert
 
3777
                            # it specially
 
3778
                            root_keys_to_create.add((file_id, entry.revision))
 
3779
                            continue
 
3780
                    text_keys.add((file_id, entry.revision))
 
3781
            revision = self.source.get_revision(current_revision_id)
 
3782
            pending_deltas.append((basis_id, delta,
 
3783
                current_revision_id, revision.parent_ids))
3888
3784
            pending_revisions.append(revision)
3889
3785
            cache[current_revision_id] = tree
3890
3786
            basis_id = current_revision_id
3891
 
        self.source._safe_to_return_from_cache = False
3892
3787
        # Copy file texts
3893
3788
        from_texts = self.source.texts
3894
3789
        to_texts = self.target.texts
3895
3790
        if root_keys_to_create:
3896
 
            root_stream = _mod_fetch._new_root_data_stream(
 
3791
            from bzrlib.fetch import _new_root_data_stream
 
3792
            root_stream = _new_root_data_stream(
3897
3793
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3898
 
                self.source, graph=a_graph)
 
3794
                self.source)
3899
3795
            to_texts.insert_record_stream(root_stream)
3900
3796
        to_texts.insert_record_stream(from_texts.get_record_stream(
3901
3797
            text_keys, self.target._format._fetch_order,
3908
3804
            # for the new revisions that we are about to insert.  We do this
3909
3805
            # before adding the revisions so that no revision is added until
3910
3806
            # all the inventories it may depend on are added.
3911
 
            # Note that this is overzealous, as we may have fetched these in an
3912
 
            # earlier batch.
3913
3807
            parent_ids = set()
3914
3808
            revision_ids = set()
3915
3809
            for revision in pending_revisions:
3918
3812
            parent_ids.difference_update(revision_ids)
3919
3813
            parent_ids.discard(_mod_revision.NULL_REVISION)
3920
3814
            parent_map = self.source.get_parent_map(parent_ids)
3921
 
            # we iterate over parent_map and not parent_ids because we don't
3922
 
            # want to try copying any revision which is a ghost
3923
 
            for parent_tree in self.source.revision_trees(parent_map):
 
3815
            for parent_tree in self.source.revision_trees(parent_ids):
 
3816
                basis_id, delta = self._get_delta_for_revision(tree, parent_ids, basis_id, cache)
3924
3817
                current_revision_id = parent_tree.get_revision_id()
3925
3818
                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
 
                basis_id, delta = self._get_delta_for_revision(parent_tree,
3932
 
                    parents_parents, possible_trees)
3933
3819
                self.target.add_inventory_by_delta(
3934
3820
                    basis_id, delta, current_revision_id, parents_parents)
3935
3821
        # insert signatures and revisions
3958
3844
        cache[basis_id] = basis_tree
3959
3845
        del basis_tree # We don't want to hang on to it here
3960
3846
        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
3847
        for offset in range(0, len(revision_ids), batch_size):
3968
3848
            self.target.start_write_group()
3969
3849
            try:
3970
3850
                pb.update('Transferring revisions', offset,
3971
3851
                          len(revision_ids))
3972
3852
                batch = revision_ids[offset:offset+batch_size]
3973
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
3974
 
                                             a_graph=a_graph)
 
3853
                basis_id = self._fetch_batch(batch, basis_id, cache)
3975
3854
            except:
3976
 
                self.source._safe_to_return_from_cache = False
3977
3855
                self.target.abort_write_group()
3978
3856
                raise
3979
3857
            else:
3991
3869
        """See InterRepository.fetch()."""
3992
3870
        if fetch_spec is not None:
3993
3871
            raise AssertionError("Not implemented yet...")
3994
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3995
3872
        if (not self.source.supports_rich_root()
3996
3873
            and self.target.supports_rich_root()):
3997
3874
            self._converting_to_rich_root = True
3998
3875
            self._revision_id_to_root_id = {}
3999
3876
        else:
4000
3877
            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
3878
        revision_ids = self.target.search_missing_revision_ids(self.source,
4007
3879
            revision_id, find_ghosts=find_ghosts).get_keys()
4008
3880
        if not revision_ids:
4077
3949
        :param to_convert: The disk object to convert.
4078
3950
        :param pb: a progress bar to use for progress information.
4079
3951
        """
4080
 
        pb = ui.ui_factory.nested_progress_bar()
 
3952
        self.pb = pb
4081
3953
        self.count = 0
4082
3954
        self.total = 4
4083
3955
        # this is only useful with metadir layouts - separated repo content.
4084
3956
        # trigger an assertion if not such
4085
3957
        repo._format.get_format_string()
4086
3958
        self.repo_dir = repo.bzrdir
4087
 
        pb.update('Moving repository to repository.backup')
 
3959
        self.step('Moving repository to repository.backup')
4088
3960
        self.repo_dir.transport.move('repository', 'repository.backup')
4089
3961
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
4090
3962
        repo._format.check_conversion_target(self.target_format)
4091
3963
        self.source_repo = repo._format.open(self.repo_dir,
4092
3964
            _found=True,
4093
3965
            _override_transport=backup_transport)
4094
 
        pb.update('Creating new repository')
 
3966
        self.step('Creating new repository')
4095
3967
        converted = self.target_format.initialize(self.repo_dir,
4096
3968
                                                  self.source_repo.is_shared())
4097
3969
        converted.lock_write()
4098
3970
        try:
4099
 
            pb.update('Copying content')
 
3971
            self.step('Copying content into repository.')
4100
3972
            self.source_repo.copy_content_into(converted)
4101
3973
        finally:
4102
3974
            converted.unlock()
4103
 
        pb.update('Deleting old repository content')
 
3975
        self.step('Deleting old repository content.')
4104
3976
        self.repo_dir.transport.delete_tree('repository.backup')
4105
 
        ui.ui_factory.note('repository converted')
4106
 
        pb.finished()
 
3977
        self.pb.note('repository converted')
 
3978
 
 
3979
    def step(self, message):
 
3980
        """Update the pb by a step."""
 
3981
        self.count +=1
 
3982
        self.pb.update(message, self.count, self.total)
4107
3983
 
4108
3984
 
4109
3985
_unescape_map = {
4329
4205
                ):
4330
4206
                if versioned_file is None:
4331
4207
                    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
4208
                missing_keys.update((prefix,) + key for key in
4340
4209
                    versioned_file.get_missing_compression_parent_keys())
4341
4210
        except NotImplementedError:
4453
4322
        fetching the inventory weave.
4454
4323
        """
4455
4324
        if self._rich_root_upgrade():
4456
 
            return _mod_fetch.Inter1and2Helper(
 
4325
            import bzrlib.fetch
 
4326
            return bzrlib.fetch.Inter1and2Helper(
4457
4327
                self.from_repository).generate_root_texts(revs)
4458
4328
        else:
4459
4329
            return []
4462
4332
        phase = 'file'
4463
4333
        revs = search.get_keys()
4464
4334
        graph = self.from_repository.get_graph()
4465
 
        revs = tsort.topo_sort(graph.get_parent_map(revs))
 
4335
        revs = list(graph.iter_topo_order(revs))
4466
4336
        data_to_fetch = self.from_repository.item_keys_introduced_by(revs)
4467
4337
        text_keys = []
4468
4338
        for knit_kind, file_id, revisions in data_to_fetch:
4535
4405
                # Some missing keys are genuinely ghosts, filter those out.
4536
4406
                present = self.from_repository.inventories.get_parent_map(keys)
4537
4407
                revs = [key[0] for key in present]
 
4408
                # As with the original stream, we may need to generate root
 
4409
                # texts for the inventories we're about to stream.
 
4410
                for _ in self._generate_root_texts(revs):
 
4411
                    yield _
4538
4412
                # Get the inventory stream more-or-less as we do for the
4539
4413
                # original stream; there's no reason to assume that records
4540
4414
                # direct from the source will be suitable for the sink.  (Think
4601
4475
 
4602
4476
    def _get_convertable_inventory_stream(self, revision_ids,
4603
4477
                                          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
 
4478
        # The source is using CHKs, but the target either doesn't or it has a
 
4479
        # different serializer.  The StreamSink code expects to be able to
4608
4480
        # 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,
 
4481
        # be converted.  That means inventory deltas (if the remote is <1.18,
4610
4482
        # RemoteStreamSink will fallback to VFS to insert the deltas).
4611
4483
        yield ('inventory-deltas',
4612
4484
           self._stream_invs_as_deltas(revision_ids,