/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: Vincent Ladeuil
  • Date: 2009-08-20 09:30:34 UTC
  • mto: This revision was merged to the branch mainline in revision 4633.
  • Revision ID: v.ladeuil+lp@free.fr-20090820093034-64jq23ddxe44tqfb
(vila)(trivial) Fix bzrtools tag used for windows installers

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
 
    fetch as _mod_fetch,
 
28
    errors,
30
29
    fifo_cache,
31
30
    generate_ids,
32
31
    gpg,
39
38
    lru_cache,
40
39
    osutils,
41
40
    revision as _mod_revision,
42
 
    static_tuple,
43
41
    symbol_versioning,
44
 
    trace,
45
42
    tsort,
46
43
    ui,
47
44
    versionedfile,
52
49
from bzrlib.testament import Testament
53
50
""")
54
51
 
55
 
from bzrlib import (
56
 
    errors,
57
 
    registry,
58
 
    )
59
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
52
from bzrlib.decorators import needs_read_lock, needs_write_lock
60
53
from bzrlib.inter import InterObject
61
54
from bzrlib.inventory import (
62
55
    Inventory,
64
57
    ROOT_ID,
65
58
    entry_factory,
66
59
    )
67
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
60
from bzrlib import registry
68
61
from bzrlib.trace import (
69
62
    log_exception_quietly, note, mutter, mutter_callsite, warning)
70
63
 
73
66
_deprecation_warning_done = False
74
67
 
75
68
 
76
 
class IsInWriteGroupError(errors.InternalBzrError):
77
 
 
78
 
    _fmt = "May not refresh_data of repo %(repo)s while in a write group."
79
 
 
80
 
    def __init__(self, repo):
81
 
        errors.InternalBzrError.__init__(self, repo=repo)
82
 
 
83
 
 
84
69
class CommitBuilder(object):
85
70
    """Provides an interface to build up a commit.
86
71
 
220
205
            # an inventory delta was accumulated without creating a new
221
206
            # inventory.
222
207
            basis_id = self.basis_delta_revision
223
 
            # We ignore the 'inventory' returned by add_inventory_by_delta
224
 
            # because self.new_inventory is used to hint to the rest of the
225
 
            # system what code path was taken
226
 
            self.inv_sha1, _ = self.repository.add_inventory_by_delta(
 
208
            self.inv_sha1 = self.repository.add_inventory_by_delta(
227
209
                basis_id, self._basis_delta, self._new_revision_id,
228
210
                self.parents)
229
211
        else:
483
465
            if content_summary[2] is None:
484
466
                raise ValueError("Files must not have executable = None")
485
467
            if not store:
486
 
                # We can't trust a check of the file length because of content
487
 
                # filtering...
488
 
                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:
489
471
                    parent_entry.executable != content_summary[2]):
490
472
                    store = True
491
473
                elif parent_entry.text_sha1 == content_summary[3]:
558
540
                ie.revision = parent_entry.revision
559
541
                return self._get_delta(ie, basis_inv, path), False, None
560
542
            ie.reference_revision = content_summary[3]
561
 
            if ie.reference_revision is None:
562
 
                raise AssertionError("invalid content_summary for nested tree: %r"
563
 
                    % (content_summary,))
564
543
            self._add_text_to_weave(ie.file_id, '', heads, None)
565
544
        else:
566
545
            raise NotImplementedError('unknown kind')
828
807
                seen_root = True
829
808
        self.new_inventory = None
830
809
        if len(inv_delta):
831
 
            # This should perhaps be guarded by a check that the basis we
832
 
            # commit against is the basis for the commit and if not do a delta
833
 
            # against the basis.
834
810
            self._any_changes = True
835
811
        if not seen_root:
836
812
            # housekeeping root entry changes do not affect no-change commits.
870
846
        # versioned roots do not change unless the tree found a change.
871
847
 
872
848
 
873
 
class RepositoryWriteLockResult(LogicalLockResult):
874
 
    """The result of write locking a repository.
875
 
 
876
 
    :ivar repository_token: The token obtained from the underlying lock, or
877
 
        None.
878
 
    :ivar unlock: A callable which will unlock the lock.
879
 
    """
880
 
 
881
 
    def __init__(self, unlock, repository_token):
882
 
        LogicalLockResult.__init__(self, unlock)
883
 
        self.repository_token = repository_token
884
 
 
885
 
    def __repr__(self):
886
 
        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
887
 
            self.unlock)
888
 
 
889
 
 
890
849
######################################################################
891
850
# Repositories
892
851
 
893
852
 
894
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
853
class Repository(object):
895
854
    """Repository holding history for one or more branches.
896
855
 
897
856
    The repository holds and retrieves historical information including
1055
1014
 
1056
1015
        :seealso: add_inventory, for the contract.
1057
1016
        """
1058
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1017
        inv_lines = self._serialise_inventory_to_lines(inv)
1059
1018
        return self._inventory_add_lines(revision_id, parents,
1060
1019
            inv_lines, check_content=False)
1061
1020
 
1257
1216
                    for record in getattr(self, kind).check(keys=keys[kind]):
1258
1217
                        if record.storage_kind == 'absent':
1259
1218
                            checker._report_items.append(
1260
 
                                'Missing %s {%s}' % (kind, record.key,))
 
1219
                                'Missing inventory {%s}' % (record.key,))
1261
1220
                        else:
1262
1221
                            last_object = self._check_record(kind, record,
1263
1222
                                checker, last_object, current_keys[(kind,) + record.key])
1268
1227
        """Check a single text from this repository."""
1269
1228
        if kind == 'inventories':
1270
1229
            rev_id = record.key[0]
1271
 
            inv = self._deserialise_inventory(rev_id,
 
1230
            inv = self.deserialise_inventory(rev_id,
1272
1231
                record.get_bytes_as('fulltext'))
1273
1232
            if last_object is not None:
1274
1233
                delta = inv._make_delta(last_object)
1318
1277
 
1319
1278
        :param _format: The format of the repository on disk.
1320
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.
1321
1284
        """
1322
 
        # In the future we will have a single api for all stores for
1323
 
        # getting file texts, inventories and revisions, then
1324
 
        # this construct will accept instances of those things.
1325
1285
        super(Repository, self).__init__()
1326
1286
        self._format = _format
1327
1287
        # the following are part of the public API for Repository:
1333
1293
        self._reconcile_does_inventory_gc = True
1334
1294
        self._reconcile_fixes_text_parents = False
1335
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()
1336
1301
        self._write_group = None
1337
1302
        # Additional places to query for data.
1338
1303
        self._fallback_repositories = []
1339
1304
        # An InventoryEntry cache, used during deserialization
1340
1305
        self._inventory_entry_cache = fifo_cache.FIFOCache(10*1024)
1341
 
        # Is it safe to return inventory entries directly from the entry cache,
1342
 
        # rather copying them?
1343
 
        self._safe_to_return_from_cache = False
1344
 
 
1345
 
    @property
1346
 
    def user_transport(self):
1347
 
        return self.bzrdir.user_transport
1348
 
 
1349
 
    @property
1350
 
    def control_transport(self):
1351
 
        return self._transport
1352
1306
 
1353
1307
    def __repr__(self):
1354
1308
        if self._fallback_repositories:
1403
1357
        data during reads, and allows a 'write_group' to be obtained. Write
1404
1358
        groups must be used for actual data insertion.
1405
1359
 
1406
 
        A token should be passed in if you know that you have locked the object
1407
 
        some other way, and need to synchronise this object's state with that
1408
 
        fact.
1409
 
 
1410
 
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1411
 
 
1412
1360
        :param token: if this is already locked, then lock_write will fail
1413
1361
            unless the token matches the existing lock.
1414
1362
        :returns: a token if this instance supports tokens, otherwise None.
1417
1365
        :raises MismatchedToken: if the specified token doesn't match the token
1418
1366
            of the existing lock.
1419
1367
        :seealso: start_write_group.
1420
 
        :return: A RepositoryWriteLockResult.
 
1368
 
 
1369
        A token should be passed in if you know that you have locked the object
 
1370
        some other way, and need to synchronise this object's state with that
 
1371
        fact.
 
1372
 
 
1373
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1421
1374
        """
1422
1375
        locked = self.is_locked()
1423
 
        token = self.control_files.lock_write(token=token)
 
1376
        result = self.control_files.lock_write(token=token)
1424
1377
        if not locked:
1425
 
            self._warn_if_deprecated()
1426
 
            self._note_lock('w')
1427
1378
            for repo in self._fallback_repositories:
1428
1379
                # Writes don't affect fallback repos
1429
1380
                repo.lock_read()
1430
1381
            self._refresh_data()
1431
 
        return RepositoryWriteLockResult(self.unlock, token)
 
1382
        return result
1432
1383
 
1433
1384
    def lock_read(self):
1434
 
        """Lock the repository for read operations.
1435
 
 
1436
 
        :return: An object with an unlock method which will release the lock
1437
 
            obtained.
1438
 
        """
1439
1385
        locked = self.is_locked()
1440
1386
        self.control_files.lock_read()
1441
1387
        if not locked:
1442
 
            self._warn_if_deprecated()
1443
 
            self._note_lock('r')
1444
1388
            for repo in self._fallback_repositories:
1445
1389
                repo.lock_read()
1446
1390
            self._refresh_data()
1447
 
        return LogicalLockResult(self.unlock)
1448
1391
 
1449
1392
    def get_physical_lock_status(self):
1450
1393
        return self.control_files.get_physical_lock_status()
1510
1453
 
1511
1454
        # now gather global repository information
1512
1455
        # XXX: This is available for many repos regardless of listability.
1513
 
        if self.user_transport.listable():
 
1456
        if self.bzrdir.root_transport.listable():
1514
1457
            # XXX: do we want to __define len__() ?
1515
1458
            # Maybe the versionedfiles object should provide a different
1516
1459
            # method to get the number of keys.
1526
1469
        :param using: If True, list only branches using this repository.
1527
1470
        """
1528
1471
        if using and not self.is_shared():
1529
 
            return self.bzrdir.list_branches()
 
1472
            try:
 
1473
                return [self.bzrdir.open_branch()]
 
1474
            except errors.NotBranchError:
 
1475
                return []
1530
1476
        class Evaluator(object):
1531
1477
 
1532
1478
            def __init__(self):
1541
1487
                    except errors.NoRepositoryPresent:
1542
1488
                        pass
1543
1489
                    else:
1544
 
                        return False, ([], repository)
 
1490
                        return False, (None, repository)
1545
1491
                self.first_call = False
1546
 
                value = (bzrdir.list_branches(), None)
 
1492
                try:
 
1493
                    value = (bzrdir.open_branch(), None)
 
1494
                except errors.NotBranchError:
 
1495
                    value = (None, None)
1547
1496
                return True, value
1548
1497
 
1549
 
        ret = []
1550
 
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1551
 
                self.user_transport, evaluate=Evaluator()):
1552
 
            if branches is not None:
1553
 
                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)
1554
1503
            if not using and repository is not None:
1555
 
                ret.extend(repository.find_branches())
1556
 
        return ret
 
1504
                branches.extend(repository.find_branches())
 
1505
        return branches
1557
1506
 
1558
1507
    @needs_read_lock
1559
1508
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1649
1598
        # but at the moment we're only checking for texts referenced by
1650
1599
        # inventories at the graph's edge.
1651
1600
        key_deps = self.revisions._index._key_dependencies
1652
 
        key_deps.satisfy_refs_for_keys(present_inventories)
 
1601
        key_deps.add_keys(present_inventories)
1653
1602
        referrers = frozenset(r[0] for r in key_deps.get_referrers())
1654
1603
        file_ids = self.fileids_altered_by_revision_ids(referrers)
1655
1604
        missing_texts = set()
1668
1617
        return missing_keys
1669
1618
 
1670
1619
    def refresh_data(self):
1671
 
        """Re-read any data needed to synchronise with disk.
 
1620
        """Re-read any data needed to to synchronise with disk.
1672
1621
 
1673
1622
        This method is intended to be called after another repository instance
1674
1623
        (such as one used by a smart server) has inserted data into the
1675
 
        repository. On all repositories this will work outside of write groups.
1676
 
        Some repository formats (pack and newer for bzrlib native formats)
1677
 
        support refresh_data inside write groups. If called inside a write
1678
 
        group on a repository that does not support refreshing in a write group
1679
 
        IsInWriteGroupError will be raised.
 
1624
        repository. It may not be called during a write group, but may be
 
1625
        called at any other time.
1680
1626
        """
 
1627
        if self.is_in_write_group():
 
1628
            raise errors.InternalBzrError(
 
1629
                "May not refresh_data while in a write group.")
1681
1630
        self._refresh_data()
1682
1631
 
1683
1632
    def resume_write_group(self, tokens):
1765
1714
        self.start_write_group()
1766
1715
        return result
1767
1716
 
1768
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1769
1717
    def unlock(self):
1770
1718
        if (self.control_files._lock_count == 1 and
1771
1719
            self.control_files._lock_mode == 'w'):
1937
1885
                rev = self._serializer.read_revision_from_string(text)
1938
1886
                yield (revid, rev)
1939
1887
 
 
1888
    @needs_read_lock
 
1889
    def get_revision_xml(self, revision_id):
 
1890
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1891
        #       would have already do it.
 
1892
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1893
        # TODO: this can't just be replaced by:
 
1894
        # return self._serializer.write_revision_to_string(
 
1895
        #     self.get_revision(revision_id))
 
1896
        # as cStringIO preservers the encoding unlike write_revision_to_string
 
1897
        # or some other call down the path.
 
1898
        rev = self.get_revision(revision_id)
 
1899
        rev_tmp = cStringIO.StringIO()
 
1900
        # the current serializer..
 
1901
        self._serializer.write_revision(rev, rev_tmp)
 
1902
        rev_tmp.seek(0)
 
1903
        return rev_tmp.getvalue()
 
1904
 
1940
1905
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1941
1906
        """Produce a generator of revision deltas.
1942
1907
 
2184
2149
        """
2185
2150
        selected_keys = set((revid,) for revid in revision_ids)
2186
2151
        w = _inv_weave or self.inventories
2187
 
        return self._find_file_ids_from_xml_inventory_lines(
2188
 
            w.iter_lines_added_or_present_in_keys(
2189
 
                selected_keys, pb=None),
2190
 
            selected_keys)
 
2152
        pb = ui.ui_factory.nested_progress_bar()
 
2153
        try:
 
2154
            return self._find_file_ids_from_xml_inventory_lines(
 
2155
                w.iter_lines_added_or_present_in_keys(
 
2156
                    selected_keys, pb=pb),
 
2157
                selected_keys)
 
2158
        finally:
 
2159
            pb.finished()
2191
2160
 
2192
2161
    def iter_files_bytes(self, desired_files):
2193
2162
        """Iterate through file versions.
2354
2323
        num_file_ids = len(file_ids)
2355
2324
        for file_id, altered_versions in file_ids.iteritems():
2356
2325
            if pb is not None:
2357
 
                pb.update("Fetch texts", count, num_file_ids)
 
2326
                pb.update("fetch texts", count, num_file_ids)
2358
2327
            count += 1
2359
2328
            yield ("file", file_id, altered_versions)
2360
2329
 
2403
2372
        """single-document based inventory iteration."""
2404
2373
        inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2405
2374
        for text, revision_id in inv_xmls:
2406
 
            yield self._deserialise_inventory(revision_id, text)
 
2375
            yield self.deserialise_inventory(revision_id, text)
2407
2376
 
2408
2377
    def _iter_inventory_xmls(self, revision_ids, ordering):
2409
2378
        if ordering is None:
2441
2410
                        next_key = None
2442
2411
                        break
2443
2412
 
2444
 
    def _deserialise_inventory(self, revision_id, xml):
 
2413
    def deserialise_inventory(self, revision_id, xml):
2445
2414
        """Transform the xml into an inventory object.
2446
2415
 
2447
2416
        :param revision_id: The expected revision id of the inventory.
2448
2417
        :param xml: A serialised inventory.
2449
2418
        """
2450
2419
        result = self._serializer.read_inventory_from_string(xml, revision_id,
2451
 
                    entry_cache=self._inventory_entry_cache,
2452
 
                    return_from_cache=self._safe_to_return_from_cache)
 
2420
                    entry_cache=self._inventory_entry_cache)
2453
2421
        if result.revision_id != revision_id:
2454
2422
            raise AssertionError('revision id mismatch %s != %s' % (
2455
2423
                result.revision_id, revision_id))
2456
2424
        return result
2457
2425
 
 
2426
    def serialise_inventory(self, inv):
 
2427
        return self._serializer.write_inventory_to_string(inv)
 
2428
 
 
2429
    def _serialise_inventory_to_lines(self, inv):
 
2430
        return self._serializer.write_inventory_to_lines(inv)
 
2431
 
2458
2432
    def get_serializer_format(self):
2459
2433
        return self._serializer.format_num
2460
2434
 
2461
2435
    @needs_read_lock
2462
 
    def _get_inventory_xml(self, revision_id):
2463
 
        """Get serialized inventory as a string."""
 
2436
    def get_inventory_xml(self, revision_id):
 
2437
        """Get inventory XML as a file object."""
2464
2438
        texts = self._iter_inventory_xmls([revision_id], 'unordered')
2465
2439
        try:
2466
2440
            text, revision_id = texts.next()
2468
2442
            raise errors.HistoryMissing(self, 'inventory', revision_id)
2469
2443
        return text
2470
2444
 
 
2445
    @needs_read_lock
 
2446
    def get_inventory_sha1(self, revision_id):
 
2447
        """Return the sha1 hash of the inventory entry
 
2448
        """
 
2449
        return self.get_revision(revision_id).inventory_sha1
 
2450
 
2471
2451
    def get_rev_id_for_revno(self, revno, known_pair):
2472
2452
        """Return the revision id of a revno, given a later (revno, revid)
2473
2453
        pair in the same history.
2524
2504
            else:
2525
2505
                next_id = parents[0]
2526
2506
 
 
2507
    @needs_read_lock
 
2508
    def get_revision_inventory(self, revision_id):
 
2509
        """Return inventory of a past revision."""
 
2510
        # TODO: Unify this with get_inventory()
 
2511
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
2512
        # must be the same as its revision, so this is trivial.
 
2513
        if revision_id is None:
 
2514
            # This does not make sense: if there is no revision,
 
2515
            # then it is the current tree inventory surely ?!
 
2516
            # and thus get_root_id() is something that looks at the last
 
2517
            # commit on the branch, and the get_root_id is an inventory check.
 
2518
            raise NotImplementedError
 
2519
            # return Inventory(self.get_root_id())
 
2520
        else:
 
2521
            return self.get_inventory(revision_id)
 
2522
 
2527
2523
    def is_shared(self):
2528
2524
        """Return True if this repository is flagged as a shared repository."""
2529
2525
        raise NotImplementedError(self.is_shared)
2563
2559
            return RevisionTree(self, Inventory(root_id=None),
2564
2560
                                _mod_revision.NULL_REVISION)
2565
2561
        else:
2566
 
            inv = self.get_inventory(revision_id)
 
2562
            inv = self.get_revision_inventory(revision_id)
2567
2563
            return RevisionTree(self, inv, revision_id)
2568
2564
 
2569
2565
    def revision_trees(self, revision_ids):
2622
2618
            keys = tsort.topo_sort(parent_map)
2623
2619
        return [None] + list(keys)
2624
2620
 
2625
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2621
    def pack(self, hint=None):
2626
2622
        """Compress the data within the repository.
2627
2623
 
2628
2624
        This operation only makes sense for some repository types. For other
2638
2634
            obtained from the result of commit_write_group(). Out of
2639
2635
            date hints are simply ignored, because concurrent operations
2640
2636
            can obsolete them rapidly.
2641
 
 
2642
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2643
 
            the pack operation.
2644
2637
        """
2645
2638
 
2646
2639
    def get_transaction(self):
2662
2655
        for ((revision_id,), parent_keys) in \
2663
2656
                self.revisions.get_parent_map(query_keys).iteritems():
2664
2657
            if parent_keys:
2665
 
                result[revision_id] = tuple([parent_revid
2666
 
                    for (parent_revid,) in parent_keys])
 
2658
                result[revision_id] = tuple(parent_revid
 
2659
                    for (parent_revid,) in parent_keys)
2667
2660
            else:
2668
2661
                result[revision_id] = (_mod_revision.NULL_REVISION,)
2669
2662
        return result
2671
2664
    def _make_parents_provider(self):
2672
2665
        return self
2673
2666
 
2674
 
    @needs_read_lock
2675
 
    def get_known_graph_ancestry(self, revision_ids):
2676
 
        """Return the known graph for a set of revision ids and their ancestors.
2677
 
        """
2678
 
        st = static_tuple.StaticTuple
2679
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
2680
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2681
 
        return graph.GraphThunkIdsToKeys(known_graph)
2682
 
 
2683
2667
    def get_graph(self, other_repository=None):
2684
2668
        """Return the graph walker for this repository format"""
2685
2669
        parents_provider = self._make_parents_provider()
2780
2764
        result.check(callback_refs)
2781
2765
        return result
2782
2766
 
2783
 
    def _warn_if_deprecated(self, branch=None):
 
2767
    def _warn_if_deprecated(self):
2784
2768
        global _deprecation_warning_done
2785
2769
        if _deprecation_warning_done:
2786
2770
            return
2787
 
        try:
2788
 
            if branch is None:
2789
 
                conf = config.GlobalConfig()
2790
 
            else:
2791
 
                conf = branch.get_config()
2792
 
            if conf.suppress_warning('format_deprecation'):
2793
 
                return
2794
 
            warning("Format %s for %s is deprecated -"
2795
 
                    " please use 'bzr upgrade' to get better performance"
2796
 
                    % (self._format, self.bzrdir.transport.base))
2797
 
        finally:
2798
 
            _deprecation_warning_done = True
 
2771
        _deprecation_warning_done = True
 
2772
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
2773
                % (self._format, self.bzrdir.transport.base))
2799
2774
 
2800
2775
    def supports_rich_root(self):
2801
2776
        return self._format.rich_root_data
3084
3059
    pack_compresses = False
3085
3060
    # Does the repository inventory storage understand references to trees?
3086
3061
    supports_tree_reference = None
3087
 
    # Is the format experimental ?
3088
 
    experimental = False
3089
3062
 
3090
 
    def __repr__(self):
3091
 
        return "%s()" % self.__class__.__name__
 
3063
    def __str__(self):
 
3064
        return "<%s>" % self.__class__.__name__
3092
3065
 
3093
3066
    def __eq__(self, other):
3094
3067
        # format objects are generally stateless
3107
3080
        """
3108
3081
        try:
3109
3082
            transport = a_bzrdir.get_repository_transport(None)
3110
 
            format_string = transport.get_bytes("format")
 
3083
            format_string = transport.get("format").read()
3111
3084
            return format_registry.get(format_string)
3112
3085
        except errors.NoSuchFile:
3113
3086
            raise errors.NoRepositoryPresent(a_bzrdir)
3212
3185
        """
3213
3186
        raise NotImplementedError(self.open)
3214
3187
 
3215
 
    def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3216
 
        from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3217
 
        hooks = BzrDir.hooks['post_repo_init']
3218
 
        if not hooks:
3219
 
            return
3220
 
        params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3221
 
        for hook in hooks:
3222
 
            hook(params)
3223
 
 
3224
3188
 
3225
3189
class MetaDirRepositoryFormat(RepositoryFormat):
3226
3190
    """Common base class for the new repositories using the metadir layout."""
3431
3395
 
3432
3396
        :param revision_id: if None all content is copied, if NULL_REVISION no
3433
3397
                            content is copied.
3434
 
        :param pb: ignored.
 
3398
        :param pb: optional progress bar to use for progress reports. If not
 
3399
                   provided a default one will be created.
3435
3400
        :return: None.
3436
3401
        """
3437
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3438
3402
        from bzrlib.fetch import RepoFetcher
3439
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
3440
 
        if self.source._format.network_name() != self.target._format.network_name():
3441
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
3442
 
                from_format=self.source._format,
3443
 
                to_format=self.target._format)
3444
3403
        f = RepoFetcher(to_repository=self.target,
3445
3404
                               from_repository=self.source,
3446
3405
                               last_revision=revision_id,
3447
3406
                               fetch_spec=fetch_spec,
3448
 
                               find_ghosts=find_ghosts)
 
3407
                               pb=pb, find_ghosts=find_ghosts)
3449
3408
 
3450
3409
    def _walk_to_common_revisions(self, revision_ids):
3451
3410
        """Walk out from revision_ids in source to revisions target has.
3620
3579
                self.target.texts.insert_record_stream(
3621
3580
                    self.source.texts.get_record_stream(
3622
3581
                        self.source.texts.keys(), 'topological', False))
3623
 
                pb.update('Copying inventory', 0, 1)
 
3582
                pb.update('copying inventory', 0, 1)
3624
3583
                self.target.inventories.insert_record_stream(
3625
3584
                    self.source.inventories.get_record_stream(
3626
3585
                        self.source.inventories.keys(), 'topological', False))
3773
3732
            return False
3774
3733
        return True
3775
3734
 
3776
 
    def _get_trees(self, revision_ids, cache):
3777
 
        possible_trees = []
3778
 
        for rev_id in revision_ids:
3779
 
            if rev_id in cache:
3780
 
                possible_trees.append((rev_id, cache[rev_id]))
3781
 
            else:
3782
 
                # Not cached, but inventory might be present anyway.
3783
 
                try:
3784
 
                    tree = self.source.revision_tree(rev_id)
3785
 
                except errors.NoSuchRevision:
3786
 
                    # Nope, parent is ghost.
3787
 
                    pass
3788
 
                else:
3789
 
                    cache[rev_id] = tree
3790
 
                    possible_trees.append((rev_id, tree))
3791
 
        return possible_trees
3792
 
 
3793
 
    def _get_delta_for_revision(self, tree, parent_ids, possible_trees):
 
3735
    def _get_delta_for_revision(self, tree, parent_ids, basis_id, cache):
3794
3736
        """Get the best delta and base for this revision.
3795
3737
 
3796
3738
        :return: (basis_id, delta)
3797
3739
        """
 
3740
        possible_trees = [(parent_id, cache[parent_id])
 
3741
                          for parent_id in parent_ids
 
3742
                           if parent_id in cache]
 
3743
        if len(possible_trees) == 0:
 
3744
            # There either aren't any parents, or the parents aren't in the
 
3745
            # cache, so just use the last converted tree
 
3746
            possible_trees.append((basis_id, cache[basis_id]))
3798
3747
        deltas = []
3799
 
        # Generate deltas against each tree, to find the shortest.
3800
 
        texts_possibly_new_in_tree = set()
3801
3748
        for basis_id, basis_tree in possible_trees:
3802
3749
            delta = tree.inventory._make_delta(basis_tree.inventory)
3803
 
            for old_path, new_path, file_id, new_entry in delta:
3804
 
                if new_path is None:
3805
 
                    # This file_id isn't present in the new rev, so we don't
3806
 
                    # care about it.
3807
 
                    continue
3808
 
                if not new_path:
3809
 
                    # Rich roots are handled elsewhere...
3810
 
                    continue
3811
 
                kind = new_entry.kind
3812
 
                if kind != 'directory' and kind != 'file':
3813
 
                    # No text record associated with this inventory entry.
3814
 
                    continue
3815
 
                # This is a directory or file that has changed somehow.
3816
 
                texts_possibly_new_in_tree.add((file_id, new_entry.revision))
3817
3750
            deltas.append((len(delta), basis_id, delta))
3818
3751
        deltas.sort()
3819
3752
        return deltas[0][1:]
3820
3753
 
3821
 
    def _fetch_parent_invs_for_stacking(self, parent_map, cache):
3822
 
        """Find all parent revisions that are absent, but for which the
3823
 
        inventory is present, and copy those inventories.
3824
 
 
3825
 
        This is necessary to preserve correctness when the source is stacked
3826
 
        without fallbacks configured.  (Note that in cases like upgrade the
3827
 
        source may be not have _fallback_repositories even though it is
3828
 
        stacked.)
3829
 
        """
3830
 
        parent_revs = set()
3831
 
        for parents in parent_map.values():
3832
 
            parent_revs.update(parents)
3833
 
        present_parents = self.source.get_parent_map(parent_revs)
3834
 
        absent_parents = set(parent_revs).difference(present_parents)
3835
 
        parent_invs_keys_for_stacking = self.source.inventories.get_parent_map(
3836
 
            (rev_id,) for rev_id in absent_parents)
3837
 
        parent_inv_ids = [key[-1] for key in parent_invs_keys_for_stacking]
3838
 
        for parent_tree in self.source.revision_trees(parent_inv_ids):
3839
 
            current_revision_id = parent_tree.get_revision_id()
3840
 
            parents_parents_keys = parent_invs_keys_for_stacking[
3841
 
                (current_revision_id,)]
3842
 
            parents_parents = [key[-1] for key in parents_parents_keys]
3843
 
            basis_id = _mod_revision.NULL_REVISION
3844
 
            basis_tree = self.source.revision_tree(basis_id)
3845
 
            delta = parent_tree.inventory._make_delta(basis_tree.inventory)
3846
 
            self.target.add_inventory_by_delta(
3847
 
                basis_id, delta, current_revision_id, parents_parents)
3848
 
            cache[current_revision_id] = parent_tree
3849
 
 
3850
 
    def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
 
3754
    def _fetch_batch(self, revision_ids, basis_id, cache):
3851
3755
        """Fetch across a few revisions.
3852
3756
 
3853
3757
        :param revision_ids: The revisions to copy
3854
3758
        :param basis_id: The revision_id of a tree that must be in cache, used
3855
3759
            as a basis for delta when no other base is available
3856
3760
        :param cache: A cache of RevisionTrees that we can use.
3857
 
        :param a_graph: A Graph object to determine the heads() of the
3858
 
            rich-root data stream.
3859
3761
        :return: The revision_id of the last converted tree. The RevisionTree
3860
3762
            for it will be in cache
3861
3763
        """
3867
3769
        pending_deltas = []
3868
3770
        pending_revisions = []
3869
3771
        parent_map = self.source.get_parent_map(revision_ids)
3870
 
        self._fetch_parent_invs_for_stacking(parent_map, cache)
3871
 
        self.source._safe_to_return_from_cache = True
3872
3772
        for tree in self.source.revision_trees(revision_ids):
3873
 
            # Find a inventory delta for this revision.
3874
 
            # Find text entries that need to be copied, too.
3875
3773
            current_revision_id = tree.get_revision_id()
3876
3774
            parent_ids = parent_map.get(current_revision_id, ())
3877
 
            parent_trees = self._get_trees(parent_ids, cache)
3878
 
            possible_trees = list(parent_trees)
3879
 
            if len(possible_trees) == 0:
3880
 
                # There either aren't any parents, or the parents are ghosts,
3881
 
                # so just use the last converted tree.
3882
 
                possible_trees.append((basis_id, cache[basis_id]))
3883
3775
            basis_id, delta = self._get_delta_for_revision(tree, parent_ids,
3884
 
                                                           possible_trees)
3885
 
            revision = self.source.get_revision(current_revision_id)
3886
 
            pending_deltas.append((basis_id, delta,
3887
 
                current_revision_id, revision.parent_ids))
 
3776
                                                           basis_id, cache)
3888
3777
            if self._converting_to_rich_root:
3889
3778
                self._revision_id_to_root_id[current_revision_id] = \
3890
3779
                    tree.get_root_id()
3891
 
            # Determine which texts are in present in this revision but not in
3892
 
            # any of the available parents.
3893
 
            texts_possibly_new_in_tree = set()
 
3780
            # Find text entries that need to be copied
3894
3781
            for old_path, new_path, file_id, entry in delta:
3895
 
                if new_path is None:
3896
 
                    # This file_id isn't present in the new rev
3897
 
                    continue
3898
 
                if not new_path:
3899
 
                    # This is the root
3900
 
                    if not self.target.supports_rich_root():
3901
 
                        # The target doesn't support rich root, so we don't
3902
 
                        # copy
3903
 
                        continue
3904
 
                    if self._converting_to_rich_root:
3905
 
                        # This can't be copied normally, we have to insert
3906
 
                        # it specially
3907
 
                        root_keys_to_create.add((file_id, entry.revision))
3908
 
                        continue
3909
 
                kind = entry.kind
3910
 
                texts_possibly_new_in_tree.add((file_id, entry.revision))
3911
 
            for basis_id, basis_tree in possible_trees:
3912
 
                basis_inv = basis_tree.inventory
3913
 
                for file_key in list(texts_possibly_new_in_tree):
3914
 
                    file_id, file_revision = file_key
3915
 
                    try:
3916
 
                        entry = basis_inv[file_id]
3917
 
                    except errors.NoSuchId:
3918
 
                        continue
3919
 
                    if entry.revision == file_revision:
3920
 
                        texts_possibly_new_in_tree.remove(file_key)
3921
 
            text_keys.update(texts_possibly_new_in_tree)
 
3782
                if new_path is not None:
 
3783
                    if not new_path:
 
3784
                        # This is the root
 
3785
                        if not self.target.supports_rich_root():
 
3786
                            # The target doesn't support rich root, so we don't
 
3787
                            # copy
 
3788
                            continue
 
3789
                        if self._converting_to_rich_root:
 
3790
                            # This can't be copied normally, we have to insert
 
3791
                            # it specially
 
3792
                            root_keys_to_create.add((file_id, entry.revision))
 
3793
                            continue
 
3794
                    text_keys.add((file_id, entry.revision))
 
3795
            revision = self.source.get_revision(current_revision_id)
 
3796
            pending_deltas.append((basis_id, delta,
 
3797
                current_revision_id, revision.parent_ids))
3922
3798
            pending_revisions.append(revision)
3923
3799
            cache[current_revision_id] = tree
3924
3800
            basis_id = current_revision_id
3925
 
        self.source._safe_to_return_from_cache = False
3926
3801
        # Copy file texts
3927
3802
        from_texts = self.source.texts
3928
3803
        to_texts = self.target.texts
3929
3804
        if root_keys_to_create:
3930
 
            root_stream = _mod_fetch._new_root_data_stream(
 
3805
            from bzrlib.fetch import _new_root_data_stream
 
3806
            root_stream = _new_root_data_stream(
3931
3807
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3932
 
                self.source, graph=a_graph)
 
3808
                self.source)
3933
3809
            to_texts.insert_record_stream(root_stream)
3934
3810
        to_texts.insert_record_stream(from_texts.get_record_stream(
3935
3811
            text_keys, self.target._format._fetch_order,
3957
3833
            for parent_tree in self.source.revision_trees(parent_map):
3958
3834
                current_revision_id = parent_tree.get_revision_id()
3959
3835
                parents_parents = parent_map[current_revision_id]
3960
 
                possible_trees = self._get_trees(parents_parents, cache)
3961
 
                if len(possible_trees) == 0:
3962
 
                    # There either aren't any parents, or the parents are
3963
 
                    # ghosts, so just use the last converted tree.
3964
 
                    possible_trees.append((basis_id, cache[basis_id]))
3965
3836
                basis_id, delta = self._get_delta_for_revision(parent_tree,
3966
 
                    parents_parents, possible_trees)
 
3837
                    parents_parents, basis_id, cache)
3967
3838
                self.target.add_inventory_by_delta(
3968
3839
                    basis_id, delta, current_revision_id, parents_parents)
3969
3840
        # insert signatures and revisions
3992
3863
        cache[basis_id] = basis_tree
3993
3864
        del basis_tree # We don't want to hang on to it here
3994
3865
        hints = []
3995
 
        if self._converting_to_rich_root and len(revision_ids) > 100:
3996
 
            a_graph = _mod_fetch._get_rich_root_heads_graph(self.source,
3997
 
                                                            revision_ids)
3998
 
        else:
3999
 
            a_graph = None
4000
 
 
4001
3866
        for offset in range(0, len(revision_ids), batch_size):
4002
3867
            self.target.start_write_group()
4003
3868
            try:
4004
3869
                pb.update('Transferring revisions', offset,
4005
3870
                          len(revision_ids))
4006
3871
                batch = revision_ids[offset:offset+batch_size]
4007
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
4008
 
                                             a_graph=a_graph)
 
3872
                basis_id = self._fetch_batch(batch, basis_id, cache)
4009
3873
            except:
4010
 
                self.source._safe_to_return_from_cache = False
4011
3874
                self.target.abort_write_group()
4012
3875
                raise
4013
3876
            else:
4025
3888
        """See InterRepository.fetch()."""
4026
3889
        if fetch_spec is not None:
4027
3890
            raise AssertionError("Not implemented yet...")
4028
 
        ui.ui_factory.warn_experimental_format_fetch(self)
4029
3891
        if (not self.source.supports_rich_root()
4030
3892
            and self.target.supports_rich_root()):
4031
3893
            self._converting_to_rich_root = True
4032
3894
            self._revision_id_to_root_id = {}
4033
3895
        else:
4034
3896
            self._converting_to_rich_root = False
4035
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
4036
 
        if self.source._format.network_name() != self.target._format.network_name():
4037
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
4038
 
                from_format=self.source._format,
4039
 
                to_format=self.target._format)
4040
3897
        revision_ids = self.target.search_missing_revision_ids(self.source,
4041
3898
            revision_id, find_ghosts=find_ghosts).get_keys()
4042
3899
        if not revision_ids:
4111
3968
        :param to_convert: The disk object to convert.
4112
3969
        :param pb: a progress bar to use for progress information.
4113
3970
        """
4114
 
        pb = ui.ui_factory.nested_progress_bar()
 
3971
        self.pb = pb
4115
3972
        self.count = 0
4116
3973
        self.total = 4
4117
3974
        # this is only useful with metadir layouts - separated repo content.
4118
3975
        # trigger an assertion if not such
4119
3976
        repo._format.get_format_string()
4120
3977
        self.repo_dir = repo.bzrdir
4121
 
        pb.update('Moving repository to repository.backup')
 
3978
        self.step('Moving repository to repository.backup')
4122
3979
        self.repo_dir.transport.move('repository', 'repository.backup')
4123
3980
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
4124
3981
        repo._format.check_conversion_target(self.target_format)
4125
3982
        self.source_repo = repo._format.open(self.repo_dir,
4126
3983
            _found=True,
4127
3984
            _override_transport=backup_transport)
4128
 
        pb.update('Creating new repository')
 
3985
        self.step('Creating new repository')
4129
3986
        converted = self.target_format.initialize(self.repo_dir,
4130
3987
                                                  self.source_repo.is_shared())
4131
3988
        converted.lock_write()
4132
3989
        try:
4133
 
            pb.update('Copying content')
 
3990
            self.step('Copying content into repository.')
4134
3991
            self.source_repo.copy_content_into(converted)
4135
3992
        finally:
4136
3993
            converted.unlock()
4137
 
        pb.update('Deleting old repository content')
 
3994
        self.step('Deleting old repository content.')
4138
3995
        self.repo_dir.transport.delete_tree('repository.backup')
4139
 
        ui.ui_factory.note('repository converted')
4140
 
        pb.finished()
 
3996
        self.pb.note('repository converted')
 
3997
 
 
3998
    def step(self, message):
 
3999
        """Update the pb by a step."""
 
4000
        self.count +=1
 
4001
        self.pb.update(message, self.count, self.total)
4141
4002
 
4142
4003
 
4143
4004
_unescape_map = {
4363
4224
                ):
4364
4225
                if versioned_file is None:
4365
4226
                    continue
4366
 
                # TODO: key is often going to be a StaticTuple object
4367
 
                #       I don't believe we can define a method by which
4368
 
                #       (prefix,) + StaticTuple will work, though we could
4369
 
                #       define a StaticTuple.sq_concat that would allow you to
4370
 
                #       pass in either a tuple or a StaticTuple as the second
4371
 
                #       object, so instead we could have:
4372
 
                #       StaticTuple(prefix) + key here...
4373
4227
                missing_keys.update((prefix,) + key for key in
4374
4228
                    versioned_file.get_missing_compression_parent_keys())
4375
4229
        except NotImplementedError:
4487
4341
        fetching the inventory weave.
4488
4342
        """
4489
4343
        if self._rich_root_upgrade():
4490
 
            return _mod_fetch.Inter1and2Helper(
 
4344
            import bzrlib.fetch
 
4345
            return bzrlib.fetch.Inter1and2Helper(
4491
4346
                self.from_repository).generate_root_texts(revs)
4492
4347
        else:
4493
4348
            return []
4635
4490
 
4636
4491
    def _get_convertable_inventory_stream(self, revision_ids,
4637
4492
                                          delta_versus_null=False):
4638
 
        # The two formats are sufficiently different that there is no fast
4639
 
        # path, so we need to send just inventorydeltas, which any
4640
 
        # sufficiently modern client can insert into any repository.
4641
 
        # The StreamSink code expects to be able to
 
4493
        # The source is using CHKs, but the target either doesn't or it has a
 
4494
        # different serializer.  The StreamSink code expects to be able to
4642
4495
        # convert on the target, so we need to put bytes-on-the-wire that can
4643
4496
        # be converted.  That means inventory deltas (if the remote is <1.19,
4644
4497
        # RemoteStreamSink will fallback to VFS to insert the deltas).