/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

Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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.
863
849
######################################################################
864
850
# Repositories
865
851
 
866
 
 
867
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
852
class Repository(object):
868
853
    """Repository holding history for one or more branches.
869
854
 
870
855
    The repository holds and retrieves historical information including
1028
1013
 
1029
1014
        :seealso: add_inventory, for the contract.
1030
1015
        """
1031
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1016
        inv_lines = self._serialise_inventory_to_lines(inv)
1032
1017
        return self._inventory_add_lines(revision_id, parents,
1033
1018
            inv_lines, check_content=False)
1034
1019
 
1083
1068
        check_content=True):
1084
1069
        """Store lines in inv_vf and return the sha1 of the inventory."""
1085
1070
        parents = [(parent,) for parent in parents]
1086
 
        result = self.inventories.add_lines((revision_id,), parents, lines,
 
1071
        return self.inventories.add_lines((revision_id,), parents, lines,
1087
1072
            check_content=check_content)[0]
1088
 
        self.inventories._access.flush()
1089
 
        return result
1090
1073
 
1091
1074
    def add_revision(self, revision_id, rev, inv=None, config=None):
1092
1075
        """Add rev to the revision store as revision_id.
1168
1151
        # The old API returned a list, should this actually be a set?
1169
1152
        return parent_map.keys()
1170
1153
 
1171
 
    def _check_inventories(self, checker):
1172
 
        """Check the inventories found from the revision scan.
1173
 
        
1174
 
        This is responsible for verifying the sha1 of inventories and
1175
 
        creating a pending_keys set that covers data referenced by inventories.
1176
 
        """
1177
 
        bar = ui.ui_factory.nested_progress_bar()
1178
 
        try:
1179
 
            self._do_check_inventories(checker, bar)
1180
 
        finally:
1181
 
            bar.finished()
1182
 
 
1183
 
    def _do_check_inventories(self, checker, bar):
1184
 
        """Helper for _check_inventories."""
1185
 
        revno = 0
1186
 
        keys = {'chk_bytes':set(), 'inventories':set(), 'texts':set()}
1187
 
        kinds = ['chk_bytes', 'texts']
1188
 
        count = len(checker.pending_keys)
1189
 
        bar.update("inventories", 0, 2)
1190
 
        current_keys = checker.pending_keys
1191
 
        checker.pending_keys = {}
1192
 
        # Accumulate current checks.
1193
 
        for key in current_keys:
1194
 
            if key[0] != 'inventories' and key[0] not in kinds:
1195
 
                checker._report_items.append('unknown key type %r' % (key,))
1196
 
            keys[key[0]].add(key[1:])
1197
 
        if keys['inventories']:
1198
 
            # NB: output order *should* be roughly sorted - topo or
1199
 
            # inverse topo depending on repository - either way decent
1200
 
            # to just delta against. However, pre-CHK formats didn't
1201
 
            # try to optimise inventory layout on disk. As such the
1202
 
            # pre-CHK code path does not use inventory deltas.
1203
 
            last_object = None
1204
 
            for record in self.inventories.check(keys=keys['inventories']):
1205
 
                if record.storage_kind == 'absent':
1206
 
                    checker._report_items.append(
1207
 
                        'Missing inventory {%s}' % (record.key,))
1208
 
                else:
1209
 
                    last_object = self._check_record('inventories', record,
1210
 
                        checker, last_object,
1211
 
                        current_keys[('inventories',) + record.key])
1212
 
            del keys['inventories']
1213
 
        else:
1214
 
            return
1215
 
        bar.update("texts", 1)
1216
 
        while (checker.pending_keys or keys['chk_bytes']
1217
 
            or keys['texts']):
1218
 
            # Something to check.
1219
 
            current_keys = checker.pending_keys
1220
 
            checker.pending_keys = {}
1221
 
            # Accumulate current checks.
1222
 
            for key in current_keys:
1223
 
                if key[0] not in kinds:
1224
 
                    checker._report_items.append('unknown key type %r' % (key,))
1225
 
                keys[key[0]].add(key[1:])
1226
 
            # Check the outermost kind only - inventories || chk_bytes || texts
1227
 
            for kind in kinds:
1228
 
                if keys[kind]:
1229
 
                    last_object = None
1230
 
                    for record in getattr(self, kind).check(keys=keys[kind]):
1231
 
                        if record.storage_kind == 'absent':
1232
 
                            checker._report_items.append(
1233
 
                                'Missing %s {%s}' % (kind, record.key,))
1234
 
                        else:
1235
 
                            last_object = self._check_record(kind, record,
1236
 
                                checker, last_object, current_keys[(kind,) + record.key])
1237
 
                    keys[kind] = set()
1238
 
                    break
1239
 
 
1240
 
    def _check_record(self, kind, record, checker, last_object, item_data):
1241
 
        """Check a single text from this repository."""
1242
 
        if kind == 'inventories':
1243
 
            rev_id = record.key[0]
1244
 
            inv = self._deserialise_inventory(rev_id,
1245
 
                record.get_bytes_as('fulltext'))
1246
 
            if last_object is not None:
1247
 
                delta = inv._make_delta(last_object)
1248
 
                for old_path, path, file_id, ie in delta:
1249
 
                    if ie is None:
1250
 
                        continue
1251
 
                    ie.check(checker, rev_id, inv)
1252
 
            else:
1253
 
                for path, ie in inv.iter_entries():
1254
 
                    ie.check(checker, rev_id, inv)
1255
 
            if self._format.fast_deltas:
1256
 
                return inv
1257
 
        elif kind == 'chk_bytes':
1258
 
            # No code written to check chk_bytes for this repo format.
1259
 
            checker._report_items.append(
1260
 
                'unsupported key type chk_bytes for %s' % (record.key,))
1261
 
        elif kind == 'texts':
1262
 
            self._check_text(record, checker, item_data)
1263
 
        else:
1264
 
            checker._report_items.append(
1265
 
                'unknown key type %s for %s' % (kind, record.key))
1266
 
 
1267
 
    def _check_text(self, record, checker, item_data):
1268
 
        """Check a single text."""
1269
 
        # Check it is extractable.
1270
 
        # TODO: check length.
1271
 
        if record.storage_kind == 'chunked':
1272
 
            chunks = record.get_bytes_as(record.storage_kind)
1273
 
            sha1 = osutils.sha_strings(chunks)
1274
 
            length = sum(map(len, chunks))
1275
 
        else:
1276
 
            content = record.get_bytes_as('fulltext')
1277
 
            sha1 = osutils.sha_string(content)
1278
 
            length = len(content)
1279
 
        if item_data and sha1 != item_data[1]:
1280
 
            checker._report_items.append(
1281
 
                'sha1 mismatch: %s has sha1 %s expected %s referenced by %s' %
1282
 
                (record.key, sha1, item_data[1], item_data[2]))
1283
 
 
1284
1154
    @staticmethod
1285
1155
    def create(a_bzrdir):
1286
1156
        """Construct the current default format repository in a_bzrdir."""
1291
1161
 
1292
1162
        :param _format: The format of the repository on disk.
1293
1163
        :param a_bzrdir: The BzrDir of the repository.
 
1164
 
 
1165
        In the future we will have a single api for all stores for
 
1166
        getting file texts, inventories and revisions, then
 
1167
        this construct will accept instances of those things.
1294
1168
        """
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
1169
        super(Repository, self).__init__()
1299
1170
        self._format = _format
1300
1171
        # the following are part of the public API for Repository:
1306
1177
        self._reconcile_does_inventory_gc = True
1307
1178
        self._reconcile_fixes_text_parents = False
1308
1179
        self._reconcile_backsup_inventory = True
 
1180
        # not right yet - should be more semantically clear ?
 
1181
        #
 
1182
        # TODO: make sure to construct the right store classes, etc, depending
 
1183
        # on whether escaping is required.
 
1184
        self._warn_if_deprecated()
1309
1185
        self._write_group = None
1310
1186
        # Additional places to query for data.
1311
1187
        self._fallback_repositories = []
1312
1188
        # An InventoryEntry cache, used during deserialization
1313
1189
        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
1190
 
1326
1191
    def __repr__(self):
1327
 
        if self._fallback_repositories:
1328
 
            return '%s(%r, fallback_repositories=%r)' % (
1329
 
                self.__class__.__name__,
1330
 
                self.base,
1331
 
                self._fallback_repositories)
1332
 
        else:
1333
 
            return '%s(%r)' % (self.__class__.__name__,
1334
 
                               self.base)
1335
 
 
1336
 
    def _has_same_fallbacks(self, other_repo):
1337
 
        """Returns true if the repositories have the same fallbacks."""
1338
 
        my_fb = self._fallback_repositories
1339
 
        other_fb = other_repo._fallback_repositories
1340
 
        if len(my_fb) != len(other_fb):
1341
 
            return False
1342
 
        for f, g in zip(my_fb, other_fb):
1343
 
            if not f.has_same_location(g):
1344
 
                return False
1345
 
        return True
 
1192
        return '%s(%r)' % (self.__class__.__name__,
 
1193
                           self.base)
1346
1194
 
1347
1195
    def has_same_location(self, other):
1348
1196
        """Returns a boolean indicating if this repository is at the same
1394
1242
        locked = self.is_locked()
1395
1243
        result = self.control_files.lock_write(token=token)
1396
1244
        if not locked:
1397
 
            self._warn_if_deprecated()
1398
 
            self._note_lock('w')
1399
1245
            for repo in self._fallback_repositories:
1400
1246
                # Writes don't affect fallback repos
1401
1247
                repo.lock_read()
1406
1252
        locked = self.is_locked()
1407
1253
        self.control_files.lock_read()
1408
1254
        if not locked:
1409
 
            self._warn_if_deprecated()
1410
 
            self._note_lock('r')
1411
1255
            for repo in self._fallback_repositories:
1412
1256
                repo.lock_read()
1413
1257
            self._refresh_data()
1476
1320
 
1477
1321
        # now gather global repository information
1478
1322
        # XXX: This is available for many repos regardless of listability.
1479
 
        if self.user_transport.listable():
 
1323
        if self.bzrdir.root_transport.listable():
1480
1324
            # XXX: do we want to __define len__() ?
1481
1325
            # Maybe the versionedfiles object should provide a different
1482
1326
            # method to get the number of keys.
1492
1336
        :param using: If True, list only branches using this repository.
1493
1337
        """
1494
1338
        if using and not self.is_shared():
1495
 
            return self.bzrdir.list_branches()
 
1339
            try:
 
1340
                return [self.bzrdir.open_branch()]
 
1341
            except errors.NotBranchError:
 
1342
                return []
1496
1343
        class Evaluator(object):
1497
1344
 
1498
1345
            def __init__(self):
1507
1354
                    except errors.NoRepositoryPresent:
1508
1355
                        pass
1509
1356
                    else:
1510
 
                        return False, ([], repository)
 
1357
                        return False, (None, repository)
1511
1358
                self.first_call = False
1512
 
                value = (bzrdir.list_branches(), None)
 
1359
                try:
 
1360
                    value = (bzrdir.open_branch(), None)
 
1361
                except errors.NotBranchError:
 
1362
                    value = (None, None)
1513
1363
                return True, value
1514
1364
 
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)
 
1365
        branches = []
 
1366
        for branch, repository in bzrdir.BzrDir.find_bzrdirs(
 
1367
                self.bzrdir.root_transport, evaluate=Evaluator()):
 
1368
            if branch is not None:
 
1369
                branches.append(branch)
1520
1370
            if not using and repository is not None:
1521
 
                ret.extend(repository.find_branches())
1522
 
        return ret
 
1371
                branches.extend(repository.find_branches())
 
1372
        return branches
1523
1373
 
1524
1374
    @needs_read_lock
1525
1375
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1554
1404
        """Commit the contents accrued within the current write group.
1555
1405
 
1556
1406
        :seealso: start_write_group.
1557
 
        
1558
 
        :return: it may return an opaque hint that can be passed to 'pack'.
1559
1407
        """
1560
1408
        if self._write_group is not self.get_transaction():
1561
1409
            # has an unlock or relock occured ?
1615
1463
        # but at the moment we're only checking for texts referenced by
1616
1464
        # inventories at the graph's edge.
1617
1465
        key_deps = self.revisions._index._key_dependencies
1618
 
        key_deps.satisfy_refs_for_keys(present_inventories)
 
1466
        key_deps.add_keys(present_inventories)
1619
1467
        referrers = frozenset(r[0] for r in key_deps.get_referrers())
1620
1468
        file_ids = self.fileids_altered_by_revision_ids(referrers)
1621
1469
        missing_texts = set()
1687
1535
            raise errors.InternalBzrError(
1688
1536
                "May not fetch while in a write group.")
1689
1537
        # fast path same-url fetch operations
1690
 
        # TODO: lift out to somewhere common with RemoteRepository
1691
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401646>
1692
 
        if (self.has_same_location(source)
1693
 
            and fetch_spec is None
1694
 
            and self._has_same_fallbacks(source)):
 
1538
        if self.has_same_location(source) and fetch_spec is None:
1695
1539
            # check that last_revision is in 'from' and then return a
1696
1540
            # no-operation.
1697
1541
            if (revision_id is not None and
1722
1566
        :param revprops: Optional dictionary of revision properties.
1723
1567
        :param revision_id: Optional revision id.
1724
1568
        """
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
1569
        result = self._commit_builder_class(self, parents, config,
1730
1570
            timestamp, timezone, committer, revprops, revision_id)
1731
1571
        self.start_write_group()
1732
1572
        return result
1733
1573
 
1734
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1735
1574
    def unlock(self):
1736
1575
        if (self.control_files._lock_count == 1 and
1737
1576
            self.control_files._lock_mode == 'w'):
1859
1698
 
1860
1699
    @needs_read_lock
1861
1700
    def get_revisions(self, revision_ids):
1862
 
        """Get many revisions at once.
1863
 
        
1864
 
        Repositories that need to check data on every revision read should 
1865
 
        subclass this method.
1866
 
        """
 
1701
        """Get many revisions at once."""
1867
1702
        return self._get_revisions(revision_ids)
1868
1703
 
1869
1704
    @needs_read_lock
1870
1705
    def _get_revisions(self, revision_ids):
1871
1706
        """Core work logic to get many revisions without sanity checks."""
 
1707
        for rev_id in revision_ids:
 
1708
            if not rev_id or not isinstance(rev_id, basestring):
 
1709
                raise errors.InvalidRevisionId(revision_id=rev_id, branch=self)
 
1710
        keys = [(key,) for key in revision_ids]
 
1711
        stream = self.revisions.get_record_stream(keys, 'unordered', True)
1872
1712
        revs = {}
1873
 
        for revid, rev in self._iter_revisions(revision_ids):
1874
 
            if rev is None:
1875
 
                raise errors.NoSuchRevision(self, revid)
1876
 
            revs[revid] = rev
 
1713
        for record in stream:
 
1714
            if record.storage_kind == 'absent':
 
1715
                raise errors.NoSuchRevision(self, record.key[0])
 
1716
            text = record.get_bytes_as('fulltext')
 
1717
            rev = self._serializer.read_revision_from_string(text)
 
1718
            revs[record.key[0]] = rev
1877
1719
        return [revs[revid] for revid in revision_ids]
1878
1720
 
1879
 
    def _iter_revisions(self, revision_ids):
1880
 
        """Iterate over revision objects.
1881
 
 
1882
 
        :param revision_ids: An iterable of revisions to examine. None may be
1883
 
            passed to request all revisions known to the repository. Note that
1884
 
            not all repositories can find unreferenced revisions; for those
1885
 
            repositories only referenced ones will be returned.
1886
 
        :return: An iterator of (revid, revision) tuples. Absent revisions (
1887
 
            those asked for but not available) are returned as (revid, None).
1888
 
        """
1889
 
        if revision_ids is None:
1890
 
            revision_ids = self.all_revision_ids()
1891
 
        else:
1892
 
            for rev_id in revision_ids:
1893
 
                if not rev_id or not isinstance(rev_id, basestring):
1894
 
                    raise errors.InvalidRevisionId(revision_id=rev_id, branch=self)
1895
 
        keys = [(key,) for key in revision_ids]
1896
 
        stream = self.revisions.get_record_stream(keys, 'unordered', True)
1897
 
        for record in stream:
1898
 
            revid = record.key[0]
1899
 
            if record.storage_kind == 'absent':
1900
 
                yield (revid, None)
1901
 
            else:
1902
 
                text = record.get_bytes_as('fulltext')
1903
 
                rev = self._serializer.read_revision_from_string(text)
1904
 
                yield (revid, rev)
 
1721
    @needs_read_lock
 
1722
    def get_revision_xml(self, revision_id):
 
1723
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1724
        #       would have already do it.
 
1725
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1726
        # TODO: this can't just be replaced by:
 
1727
        # return self._serializer.write_revision_to_string(
 
1728
        #     self.get_revision(revision_id))
 
1729
        # as cStringIO preservers the encoding unlike write_revision_to_string
 
1730
        # or some other call down the path.
 
1731
        rev = self.get_revision(revision_id)
 
1732
        rev_tmp = cStringIO.StringIO()
 
1733
        # the current serializer..
 
1734
        self._serializer.write_revision(rev, rev_tmp)
 
1735
        rev_tmp.seek(0)
 
1736
        return rev_tmp.getvalue()
1905
1737
 
1906
1738
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1907
1739
        """Produce a generator of revision deltas.
2150
1982
        """
2151
1983
        selected_keys = set((revid,) for revid in revision_ids)
2152
1984
        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)
 
1985
        pb = ui.ui_factory.nested_progress_bar()
 
1986
        try:
 
1987
            return self._find_file_ids_from_xml_inventory_lines(
 
1988
                w.iter_lines_added_or_present_in_keys(
 
1989
                    selected_keys, pb=pb),
 
1990
                selected_keys)
 
1991
        finally:
 
1992
            pb.finished()
2157
1993
 
2158
1994
    def iter_files_bytes(self, desired_files):
2159
1995
        """Iterate through file versions.
2241
2077
                batch_size]
2242
2078
            if not to_query:
2243
2079
                break
2244
 
            for revision_id in to_query:
 
2080
            for rev_tree in self.revision_trees(to_query):
 
2081
                revision_id = rev_tree.get_revision_id()
2245
2082
                parent_ids = ancestors[revision_id]
2246
2083
                for text_key in revision_keys[revision_id]:
2247
2084
                    pb.update("Calculating text parents", processed_texts)
2320
2157
        num_file_ids = len(file_ids)
2321
2158
        for file_id, altered_versions in file_ids.iteritems():
2322
2159
            if pb is not None:
2323
 
                pb.update("Fetch texts", count, num_file_ids)
 
2160
                pb.update("fetch texts", count, num_file_ids)
2324
2161
            count += 1
2325
2162
            yield ("file", file_id, altered_versions)
2326
2163
 
2347
2184
        """Get Inventory object by revision id."""
2348
2185
        return self.iter_inventories([revision_id]).next()
2349
2186
 
2350
 
    def iter_inventories(self, revision_ids, ordering=None):
 
2187
    def iter_inventories(self, revision_ids, ordering='unordered'):
2351
2188
        """Get many inventories by revision_ids.
2352
2189
 
2353
2190
        This will buffer some or all of the texts used in constructing the
2355
2192
        time.
2356
2193
 
2357
2194
        :param revision_ids: The expected revision ids of the inventories.
2358
 
        :param ordering: optional ordering, e.g. 'topological'.  If not
2359
 
            specified, the order of revision_ids will be preserved (by
2360
 
            buffering if necessary).
 
2195
        :param ordering: optional ordering, e.g. 'topological'.
2361
2196
        :return: An iterator of inventories.
2362
2197
        """
2363
2198
        if ((None in revision_ids)
2369
2204
        """single-document based inventory iteration."""
2370
2205
        inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2371
2206
        for text, revision_id in inv_xmls:
2372
 
            yield self._deserialise_inventory(revision_id, text)
 
2207
            yield self.deserialise_inventory(revision_id, text)
2373
2208
 
2374
 
    def _iter_inventory_xmls(self, revision_ids, ordering):
2375
 
        if ordering is None:
2376
 
            order_as_requested = True
2377
 
            ordering = 'unordered'
2378
 
        else:
2379
 
            order_as_requested = False
 
2209
    def _iter_inventory_xmls(self, revision_ids, ordering='unordered'):
2380
2210
        keys = [(revision_id,) for revision_id in revision_ids]
2381
 
        if not keys:
2382
 
            return
2383
 
        if order_as_requested:
2384
 
            key_iter = iter(keys)
2385
 
            next_key = key_iter.next()
2386
2211
        stream = self.inventories.get_record_stream(keys, ordering, True)
2387
2212
        text_chunks = {}
2388
2213
        for record in stream:
2389
2214
            if record.storage_kind != 'absent':
2390
 
                chunks = record.get_bytes_as('chunked')
2391
 
                if order_as_requested:
2392
 
                    text_chunks[record.key] = chunks
2393
 
                else:
2394
 
                    yield ''.join(chunks), record.key[-1]
 
2215
                text_chunks[record.key] = record.get_bytes_as('chunked')
2395
2216
            else:
2396
2217
                raise errors.NoSuchRevision(self, record.key)
2397
 
            if order_as_requested:
2398
 
                # Yield as many results as we can while preserving order.
2399
 
                while next_key in text_chunks:
2400
 
                    chunks = text_chunks.pop(next_key)
2401
 
                    yield ''.join(chunks), next_key[-1]
2402
 
                    try:
2403
 
                        next_key = key_iter.next()
2404
 
                    except StopIteration:
2405
 
                        # We still want to fully consume the get_record_stream,
2406
 
                        # just in case it is not actually finished at this point
2407
 
                        next_key = None
2408
 
                        break
 
2218
        for key in keys:
 
2219
            chunks = text_chunks.pop(key)
 
2220
            yield ''.join(chunks), key[-1]
2409
2221
 
2410
 
    def _deserialise_inventory(self, revision_id, xml):
 
2222
    def deserialise_inventory(self, revision_id, xml):
2411
2223
        """Transform the xml into an inventory object.
2412
2224
 
2413
2225
        :param revision_id: The expected revision id of the inventory.
2414
2226
        :param xml: A serialised inventory.
2415
2227
        """
2416
2228
        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)
 
2229
                    entry_cache=self._inventory_entry_cache)
2419
2230
        if result.revision_id != revision_id:
2420
2231
            raise AssertionError('revision id mismatch %s != %s' % (
2421
2232
                result.revision_id, revision_id))
2422
2233
        return result
2423
2234
 
 
2235
    def serialise_inventory(self, inv):
 
2236
        return self._serializer.write_inventory_to_string(inv)
 
2237
 
 
2238
    def _serialise_inventory_to_lines(self, inv):
 
2239
        return self._serializer.write_inventory_to_lines(inv)
 
2240
 
2424
2241
    def get_serializer_format(self):
2425
2242
        return self._serializer.format_num
2426
2243
 
2427
2244
    @needs_read_lock
2428
 
    def _get_inventory_xml(self, revision_id):
2429
 
        """Get serialized inventory as a string."""
 
2245
    def get_inventory_xml(self, revision_id):
 
2246
        """Get inventory XML as a file object."""
2430
2247
        texts = self._iter_inventory_xmls([revision_id], 'unordered')
2431
2248
        try:
2432
2249
            text, revision_id = texts.next()
2434
2251
            raise errors.HistoryMissing(self, 'inventory', revision_id)
2435
2252
        return text
2436
2253
 
 
2254
    @needs_read_lock
 
2255
    def get_inventory_sha1(self, revision_id):
 
2256
        """Return the sha1 hash of the inventory entry
 
2257
        """
 
2258
        return self.get_revision(revision_id).inventory_sha1
 
2259
 
2437
2260
    def get_rev_id_for_revno(self, revno, known_pair):
2438
2261
        """Return the revision id of a revno, given a later (revno, revid)
2439
2262
        pair in the same history.
2490
2313
            else:
2491
2314
                next_id = parents[0]
2492
2315
 
 
2316
    @needs_read_lock
 
2317
    def get_revision_inventory(self, revision_id):
 
2318
        """Return inventory of a past revision."""
 
2319
        # TODO: Unify this with get_inventory()
 
2320
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
2321
        # must be the same as its revision, so this is trivial.
 
2322
        if revision_id is None:
 
2323
            # This does not make sense: if there is no revision,
 
2324
            # then it is the current tree inventory surely ?!
 
2325
            # and thus get_root_id() is something that looks at the last
 
2326
            # commit on the branch, and the get_root_id is an inventory check.
 
2327
            raise NotImplementedError
 
2328
            # return Inventory(self.get_root_id())
 
2329
        else:
 
2330
            return self.get_inventory(revision_id)
 
2331
 
2493
2332
    def is_shared(self):
2494
2333
        """Return True if this repository is flagged as a shared repository."""
2495
2334
        raise NotImplementedError(self.is_shared)
2529
2368
            return RevisionTree(self, Inventory(root_id=None),
2530
2369
                                _mod_revision.NULL_REVISION)
2531
2370
        else:
2532
 
            inv = self.get_inventory(revision_id)
 
2371
            inv = self.get_revision_inventory(revision_id)
2533
2372
            return RevisionTree(self, inv, revision_id)
2534
2373
 
2535
2374
    def revision_trees(self, revision_ids):
2588
2427
            keys = tsort.topo_sort(parent_map)
2589
2428
        return [None] + list(keys)
2590
2429
 
2591
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2430
    def pack(self, hint=None):
2592
2431
        """Compress the data within the repository.
2593
2432
 
2594
2433
        This operation only makes sense for some repository types. For other
2604
2443
            obtained from the result of commit_write_group(). Out of
2605
2444
            date hints are simply ignored, because concurrent operations
2606
2445
            can obsolete them rapidly.
2607
 
 
2608
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2609
 
            the pack operation.
2610
2446
        """
2611
2447
 
2612
2448
    def get_transaction(self):
2628
2464
        for ((revision_id,), parent_keys) in \
2629
2465
                self.revisions.get_parent_map(query_keys).iteritems():
2630
2466
            if parent_keys:
2631
 
                result[revision_id] = tuple([parent_revid
2632
 
                    for (parent_revid,) in parent_keys])
 
2467
                result[revision_id] = tuple(parent_revid
 
2468
                    for (parent_revid,) in parent_keys)
2633
2469
            else:
2634
2470
                result[revision_id] = (_mod_revision.NULL_REVISION,)
2635
2471
        return result
2637
2473
    def _make_parents_provider(self):
2638
2474
        return self
2639
2475
 
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
2476
    def get_graph(self, other_repository=None):
2650
2477
        """Return the graph walker for this repository format"""
2651
2478
        parents_provider = self._make_parents_provider()
2655
2482
                [parents_provider, other_repository._make_parents_provider()])
2656
2483
        return graph.Graph(parents_provider)
2657
2484
 
2658
 
    def _get_versioned_file_checker(self, text_key_references=None,
2659
 
        ancestors=None):
 
2485
    def _get_versioned_file_checker(self, text_key_references=None):
2660
2486
        """Return an object suitable for checking versioned files.
2661
2487
        
2662
2488
        :param text_key_references: if non-None, an already built
2664
2490
            to whether they were referred to by the inventory of the
2665
2491
            revision_id that they contain. If None, this will be
2666
2492
            calculated.
2667
 
        :param ancestors: Optional result from
2668
 
            self.get_graph().get_parent_map(self.all_revision_ids()) if already
2669
 
            available.
2670
2493
        """
2671
2494
        return _VersionedFileChecker(self,
2672
 
            text_key_references=text_key_references, ancestors=ancestors)
 
2495
            text_key_references=text_key_references)
2673
2496
 
2674
2497
    def revision_ids_to_search_result(self, result_set):
2675
2498
        """Convert a set of revision ids to a graph SearchResult."""
2725
2548
        return record.get_bytes_as('fulltext')
2726
2549
 
2727
2550
    @needs_read_lock
2728
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
2551
    def check(self, revision_ids=None):
2729
2552
        """Check consistency of all history of given revision_ids.
2730
2553
 
2731
2554
        Different repository implementations should override _check().
2732
2555
 
2733
2556
        :param revision_ids: A non-empty list of revision_ids whose ancestry
2734
2557
             will be checked.  Typically the last revision_id of a branch.
2735
 
        :param callback_refs: A dict of check-refs to resolve and callback
2736
 
            the check/_check method on the items listed as wanting the ref.
2737
 
            see bzrlib.check.
2738
 
        :param check_repo: If False do not check the repository contents, just 
2739
 
            calculate the data callback_refs requires and call them back.
2740
2558
        """
2741
 
        return self._check(revision_ids, callback_refs=callback_refs,
2742
 
            check_repo=check_repo)
 
2559
        return self._check(revision_ids)
2743
2560
 
2744
 
    def _check(self, revision_ids, callback_refs, check_repo):
2745
 
        result = check.Check(self, check_repo=check_repo)
2746
 
        result.check(callback_refs)
 
2561
    def _check(self, revision_ids):
 
2562
        result = check.Check(self)
 
2563
        result.check()
2747
2564
        return result
2748
2565
 
2749
 
    def _warn_if_deprecated(self, branch=None):
 
2566
    def _warn_if_deprecated(self):
2750
2567
        global _deprecation_warning_done
2751
2568
        if _deprecation_warning_done:
2752
2569
            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
 
2570
        _deprecation_warning_done = True
 
2571
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
2572
                % (self._format, self.bzrdir.transport.base))
2765
2573
 
2766
2574
    def supports_rich_root(self):
2767
2575
        return self._format.rich_root_data
3048
2856
    # help), and for fetching when data won't have come from the same
3049
2857
    # compressor.
3050
2858
    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
2859
 
3056
 
    def __repr__(self):
3057
 
        return "%s()" % self.__class__.__name__
 
2860
    def __str__(self):
 
2861
        return "<%s>" % self.__class__.__name__
3058
2862
 
3059
2863
    def __eq__(self, other):
3060
2864
        # format objects are generally stateless
3073
2877
        """
3074
2878
        try:
3075
2879
            transport = a_bzrdir.get_repository_transport(None)
3076
 
            format_string = transport.get_bytes("format")
 
2880
            format_string = transport.get("format").read()
3077
2881
            return format_registry.get(format_string)
3078
2882
        except errors.NoSuchFile:
3079
2883
            raise errors.NoRepositoryPresent(a_bzrdir)
3161
2965
        raise NotImplementedError(self.network_name)
3162
2966
 
3163
2967
    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)
 
2968
        raise NotImplementedError(self.check_conversion_target)
3173
2969
 
3174
2970
    def open(self, a_bzrdir, _found=False):
3175
2971
        """Return an instance of this format for the bzrdir a_bzrdir.
3178
2974
        """
3179
2975
        raise NotImplementedError(self.open)
3180
2976
 
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
2977
 
3191
2978
class MetaDirRepositoryFormat(RepositoryFormat):
3192
2979
    """Common base class for the new repositories using the metadir layout."""
3397
3184
 
3398
3185
        :param revision_id: if None all content is copied, if NULL_REVISION no
3399
3186
                            content is copied.
3400
 
        :param pb: ignored.
 
3187
        :param pb: optional progress bar to use for progress reports. If not
 
3188
                   provided a default one will be created.
3401
3189
        :return: None.
3402
3190
        """
3403
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3404
3191
        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
3192
        f = RepoFetcher(to_repository=self.target,
3411
3193
                               from_repository=self.source,
3412
3194
                               last_revision=revision_id,
3413
3195
                               fetch_spec=fetch_spec,
3414
 
                               find_ghosts=find_ghosts)
 
3196
                               pb=pb, find_ghosts=find_ghosts)
3415
3197
 
3416
3198
    def _walk_to_common_revisions(self, revision_ids):
3417
3199
        """Walk out from revision_ids in source to revisions target has.
3586
3368
                self.target.texts.insert_record_stream(
3587
3369
                    self.source.texts.get_record_stream(
3588
3370
                        self.source.texts.keys(), 'topological', False))
3589
 
                pb.update('Copying inventory', 0, 1)
 
3371
                pb.update('copying inventory', 0, 1)
3590
3372
                self.target.inventories.insert_record_stream(
3591
3373
                    self.source.inventories.get_record_stream(
3592
3374
                        self.source.inventories.keys(), 'topological', False))
3706
3488
        return self.source.revision_ids_to_search_result(result_set)
3707
3489
 
3708
3490
 
3709
 
class InterDifferingSerializer(InterRepository):
3710
 
 
3711
 
    @classmethod
3712
 
    def _get_repo_format_to_test(self):
3713
 
        return None
3714
 
 
3715
 
    @staticmethod
3716
 
    def is_compatible(source, target):
3717
 
        """Be compatible with Knit2 source and Knit3 target"""
3718
 
        # This is redundant with format.check_conversion_target(), however that
3719
 
        # raises an exception, and we just want to say "False" as in we won't
3720
 
        # support converting between these formats.
3721
 
        if 'IDS_never' in debug.debug_flags:
3722
 
            return False
3723
 
        if source.supports_rich_root() and not target.supports_rich_root():
3724
 
            return False
3725
 
        if (source._format.supports_tree_reference
3726
 
            and not target._format.supports_tree_reference):
3727
 
            return False
3728
 
        if target._fallback_repositories and target._format.supports_chks:
3729
 
            # IDS doesn't know how to copy CHKs for the parent inventories it
3730
 
            # adds to stacked repos.
3731
 
            return False
3732
 
        if 'IDS_always' in debug.debug_flags:
3733
 
            return True
3734
 
        # Only use this code path for local source and target.  IDS does far
3735
 
        # too much IO (both bandwidth and roundtrips) over a network.
3736
 
        if not source.bzrdir.transport.base.startswith('file:///'):
3737
 
            return False
3738
 
        if not target.bzrdir.transport.base.startswith('file:///'):
3739
 
            return False
3740
 
        return True
3741
 
 
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):
3760
 
        """Get the best delta and base for this revision.
3761
 
 
3762
 
        :return: (basis_id, delta)
3763
 
        """
3764
 
        deltas = []
3765
 
        # Generate deltas against each tree, to find the shortest.
3766
 
        texts_possibly_new_in_tree = set()
3767
 
        for basis_id, basis_tree in possible_trees:
3768
 
            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
 
            deltas.append((len(delta), basis_id, delta))
3784
 
        deltas.sort()
3785
 
        return deltas[0][1:]
3786
 
 
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):
3817
 
        """Fetch across a few revisions.
3818
 
 
3819
 
        :param revision_ids: The revisions to copy
3820
 
        :param basis_id: The revision_id of a tree that must be in cache, used
3821
 
            as a basis for delta when no other base is available
3822
 
        :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
 
        :return: The revision_id of the last converted tree. The RevisionTree
3826
 
            for it will be in cache
3827
 
        """
3828
 
        # Walk though all revisions; get inventory deltas, copy referenced
3829
 
        # texts that delta references, insert the delta, revision and
3830
 
        # signature.
3831
 
        root_keys_to_create = set()
3832
 
        text_keys = set()
3833
 
        pending_deltas = []
3834
 
        pending_revisions = []
3835
 
        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
 
        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
 
            current_revision_id = tree.get_revision_id()
3842
 
            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
 
            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))
3854
 
            if self._converting_to_rich_root:
3855
 
                self._revision_id_to_root_id[current_revision_id] = \
3856
 
                    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()
3860
 
            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)
3888
 
            pending_revisions.append(revision)
3889
 
            cache[current_revision_id] = tree
3890
 
            basis_id = current_revision_id
3891
 
        self.source._safe_to_return_from_cache = False
3892
 
        # Copy file texts
3893
 
        from_texts = self.source.texts
3894
 
        to_texts = self.target.texts
3895
 
        if root_keys_to_create:
3896
 
            root_stream = _mod_fetch._new_root_data_stream(
3897
 
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3898
 
                self.source, graph=a_graph)
3899
 
            to_texts.insert_record_stream(root_stream)
3900
 
        to_texts.insert_record_stream(from_texts.get_record_stream(
3901
 
            text_keys, self.target._format._fetch_order,
3902
 
            not self.target._format._fetch_uses_deltas))
3903
 
        # insert inventory deltas
3904
 
        for delta in pending_deltas:
3905
 
            self.target.add_inventory_by_delta(*delta)
3906
 
        if self.target._fallback_repositories:
3907
 
            # Make sure this stacked repository has all the parent inventories
3908
 
            # for the new revisions that we are about to insert.  We do this
3909
 
            # before adding the revisions so that no revision is added until
3910
 
            # 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
 
            parent_ids = set()
3914
 
            revision_ids = set()
3915
 
            for revision in pending_revisions:
3916
 
                revision_ids.add(revision.revision_id)
3917
 
                parent_ids.update(revision.parent_ids)
3918
 
            parent_ids.difference_update(revision_ids)
3919
 
            parent_ids.discard(_mod_revision.NULL_REVISION)
3920
 
            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):
3924
 
                current_revision_id = parent_tree.get_revision_id()
3925
 
                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
 
                self.target.add_inventory_by_delta(
3934
 
                    basis_id, delta, current_revision_id, parents_parents)
3935
 
        # insert signatures and revisions
3936
 
        for revision in pending_revisions:
3937
 
            try:
3938
 
                signature = self.source.get_signature_text(
3939
 
                    revision.revision_id)
3940
 
                self.target.add_signature_text(revision.revision_id,
3941
 
                    signature)
3942
 
            except errors.NoSuchRevision:
3943
 
                pass
3944
 
            self.target.add_revision(revision.revision_id, revision)
3945
 
        return basis_id
3946
 
 
3947
 
    def _fetch_all_revisions(self, revision_ids, pb):
3948
 
        """Fetch everything for the list of revisions.
3949
 
 
3950
 
        :param revision_ids: The list of revisions to fetch. Must be in
3951
 
            topological order.
3952
 
        :param pb: A ProgressTask
3953
 
        :return: None
3954
 
        """
3955
 
        basis_id, basis_tree = self._get_basis(revision_ids[0])
3956
 
        batch_size = 100
3957
 
        cache = lru_cache.LRUCache(100)
3958
 
        cache[basis_id] = basis_tree
3959
 
        del basis_tree # We don't want to hang on to it here
3960
 
        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
 
        for offset in range(0, len(revision_ids), batch_size):
3968
 
            self.target.start_write_group()
3969
 
            try:
3970
 
                pb.update('Transferring revisions', offset,
3971
 
                          len(revision_ids))
3972
 
                batch = revision_ids[offset:offset+batch_size]
3973
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
3974
 
                                             a_graph=a_graph)
3975
 
            except:
3976
 
                self.source._safe_to_return_from_cache = False
3977
 
                self.target.abort_write_group()
3978
 
                raise
3979
 
            else:
3980
 
                hint = self.target.commit_write_group()
3981
 
                if hint:
3982
 
                    hints.extend(hint)
3983
 
        if hints and self.target._format.pack_compresses:
3984
 
            self.target.pack(hint=hints)
3985
 
        pb.update('Transferring revisions', len(revision_ids),
3986
 
                  len(revision_ids))
3987
 
 
3988
 
    @needs_write_lock
3989
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
3990
 
            fetch_spec=None):
3991
 
        """See InterRepository.fetch()."""
3992
 
        if fetch_spec is not None:
3993
 
            raise AssertionError("Not implemented yet...")
3994
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3995
 
        if (not self.source.supports_rich_root()
3996
 
            and self.target.supports_rich_root()):
3997
 
            self._converting_to_rich_root = True
3998
 
            self._revision_id_to_root_id = {}
3999
 
        else:
4000
 
            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
 
        revision_ids = self.target.search_missing_revision_ids(self.source,
4007
 
            revision_id, find_ghosts=find_ghosts).get_keys()
4008
 
        if not revision_ids:
4009
 
            return 0, 0
4010
 
        revision_ids = tsort.topo_sort(
4011
 
            self.source.get_graph().get_parent_map(revision_ids))
4012
 
        if not revision_ids:
4013
 
            return 0, 0
4014
 
        # Walk though all revisions; get inventory deltas, copy referenced
4015
 
        # texts that delta references, insert the delta, revision and
4016
 
        # signature.
4017
 
        if pb is None:
4018
 
            my_pb = ui.ui_factory.nested_progress_bar()
4019
 
            pb = my_pb
4020
 
        else:
4021
 
            symbol_versioning.warn(
4022
 
                symbol_versioning.deprecated_in((1, 14, 0))
4023
 
                % "pb parameter to fetch()")
4024
 
            my_pb = None
4025
 
        try:
4026
 
            self._fetch_all_revisions(revision_ids, pb)
4027
 
        finally:
4028
 
            if my_pb is not None:
4029
 
                my_pb.finished()
4030
 
        return len(revision_ids), 0
4031
 
 
4032
 
    def _get_basis(self, first_revision_id):
4033
 
        """Get a revision and tree which exists in the target.
4034
 
 
4035
 
        This assumes that first_revision_id is selected for transmission
4036
 
        because all other ancestors are already present. If we can't find an
4037
 
        ancestor we fall back to NULL_REVISION since we know that is safe.
4038
 
 
4039
 
        :return: (basis_id, basis_tree)
4040
 
        """
4041
 
        first_rev = self.source.get_revision(first_revision_id)
4042
 
        try:
4043
 
            basis_id = first_rev.parent_ids[0]
4044
 
            # only valid as a basis if the target has it
4045
 
            self.target.get_revision(basis_id)
4046
 
            # Try to get a basis tree - if its a ghost it will hit the
4047
 
            # NoSuchRevision case.
4048
 
            basis_tree = self.source.revision_tree(basis_id)
4049
 
        except (IndexError, errors.NoSuchRevision):
4050
 
            basis_id = _mod_revision.NULL_REVISION
4051
 
            basis_tree = self.source.revision_tree(basis_id)
4052
 
        return basis_id, basis_tree
4053
 
 
4054
 
 
4055
 
InterRepository.register_optimiser(InterDifferingSerializer)
4056
3491
InterRepository.register_optimiser(InterSameDataRepository)
4057
3492
InterRepository.register_optimiser(InterWeaveRepo)
4058
3493
InterRepository.register_optimiser(InterKnitRepo)
4077
3512
        :param to_convert: The disk object to convert.
4078
3513
        :param pb: a progress bar to use for progress information.
4079
3514
        """
4080
 
        pb = ui.ui_factory.nested_progress_bar()
 
3515
        self.pb = pb
4081
3516
        self.count = 0
4082
3517
        self.total = 4
4083
3518
        # this is only useful with metadir layouts - separated repo content.
4084
3519
        # trigger an assertion if not such
4085
3520
        repo._format.get_format_string()
4086
3521
        self.repo_dir = repo.bzrdir
4087
 
        pb.update('Moving repository to repository.backup')
 
3522
        self.step('Moving repository to repository.backup')
4088
3523
        self.repo_dir.transport.move('repository', 'repository.backup')
4089
3524
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
4090
3525
        repo._format.check_conversion_target(self.target_format)
4091
3526
        self.source_repo = repo._format.open(self.repo_dir,
4092
3527
            _found=True,
4093
3528
            _override_transport=backup_transport)
4094
 
        pb.update('Creating new repository')
 
3529
        self.step('Creating new repository')
4095
3530
        converted = self.target_format.initialize(self.repo_dir,
4096
3531
                                                  self.source_repo.is_shared())
4097
3532
        converted.lock_write()
4098
3533
        try:
4099
 
            pb.update('Copying content')
 
3534
            self.step('Copying content into repository.')
4100
3535
            self.source_repo.copy_content_into(converted)
4101
3536
        finally:
4102
3537
            converted.unlock()
4103
 
        pb.update('Deleting old repository content')
 
3538
        self.step('Deleting old repository content.')
4104
3539
        self.repo_dir.transport.delete_tree('repository.backup')
4105
 
        ui.ui_factory.note('repository converted')
4106
 
        pb.finished()
 
3540
        self.pb.note('repository converted')
 
3541
 
 
3542
    def step(self, message):
 
3543
        """Update the pb by a step."""
 
3544
        self.count +=1
 
3545
        self.pb.update(message, self.count, self.total)
4107
3546
 
4108
3547
 
4109
3548
_unescape_map = {
4138
3577
 
4139
3578
class _VersionedFileChecker(object):
4140
3579
 
4141
 
    def __init__(self, repository, text_key_references=None, ancestors=None):
 
3580
    def __init__(self, repository, text_key_references=None):
4142
3581
        self.repository = repository
4143
3582
        self.text_index = self.repository._generate_text_key_index(
4144
 
            text_key_references=text_key_references, ancestors=ancestors)
 
3583
            text_key_references=text_key_references)
4145
3584
 
4146
3585
    def calculate_file_version_parents(self, text_key):
4147
3586
        """Calculate the correct parents for a file version according to
4165
3604
            revision_id) tuples for versions that are present in this versioned
4166
3605
            file, but not used by the corresponding inventory.
4167
3606
        """
4168
 
        local_progress = None
4169
 
        if progress_bar is None:
4170
 
            local_progress = ui.ui_factory.nested_progress_bar()
4171
 
            progress_bar = local_progress
4172
 
        try:
4173
 
            return self._check_file_version_parents(texts, progress_bar)
4174
 
        finally:
4175
 
            if local_progress:
4176
 
                local_progress.finished()
4177
 
 
4178
 
    def _check_file_version_parents(self, texts, progress_bar):
4179
 
        """See check_file_version_parents."""
4180
3607
        wrong_parents = {}
4181
3608
        self.file_ids = set([file_id for file_id, _ in
4182
3609
            self.text_index.iterkeys()])
4188
3615
        text_keys = self.repository.texts.keys()
4189
3616
        unused_keys = frozenset(text_keys) - set(self.text_index)
4190
3617
        for num, key in enumerate(self.text_index.iterkeys()):
4191
 
            progress_bar.update('checking text graph', num, n_versions)
 
3618
            if progress_bar is not None:
 
3619
                progress_bar.update('checking text graph', num, n_versions)
4192
3620
            correct_parents = self.calculate_file_version_parents(key)
4193
3621
            try:
4194
3622
                knit_parents = parent_map[key]
4278
3706
                pass
4279
3707
            else:
4280
3708
                new_pack.set_write_cache_size(1024*1024)
 
3709
        delta_deserializer = inventory_delta.InventoryDeltaSerializer()
4281
3710
        for substream_type, substream in stream:
4282
 
            if 'stream' in debug.debug_flags:
4283
 
                mutter('inserting substream: %s', substream_type)
4284
3711
            if substream_type == 'texts':
4285
3712
                self.target_repo.texts.insert_record_stream(substream)
4286
3713
            elif substream_type == 'inventories':
4289
3716
                        substream)
4290
3717
                else:
4291
3718
                    self._extract_and_insert_inventories(
4292
 
                        substream, src_serializer)
4293
 
            elif substream_type == 'inventory-deltas':
4294
 
                self._extract_and_insert_inventory_deltas(
4295
 
                    substream, src_serializer)
 
3719
                        substream, src_serializer,
 
3720
                        delta_deserializer.parse_text_bytes)
4296
3721
            elif substream_type == 'chk_bytes':
4297
3722
                # XXX: This doesn't support conversions, as it assumes the
4298
3723
                #      conversion was done in the fetch code.
4329
3754
                ):
4330
3755
                if versioned_file is None:
4331
3756
                    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
3757
                missing_keys.update((prefix,) + key for key in
4340
3758
                    versioned_file.get_missing_compression_parent_keys())
4341
3759
        except NotImplementedError:
4356
3774
            self.target_repo.pack(hint=hint)
4357
3775
        return [], set()
4358
3776
 
4359
 
    def _extract_and_insert_inventory_deltas(self, substream, serializer):
4360
 
        target_rich_root = self.target_repo._format.rich_root_data
4361
 
        target_tree_refs = self.target_repo._format.supports_tree_reference
4362
 
        for record in substream:
4363
 
            # Insert the delta directly
4364
 
            inventory_delta_bytes = record.get_bytes_as('fulltext')
4365
 
            deserialiser = inventory_delta.InventoryDeltaDeserializer()
4366
 
            try:
4367
 
                parse_result = deserialiser.parse_text_bytes(
4368
 
                    inventory_delta_bytes)
4369
 
            except inventory_delta.IncompatibleInventoryDelta, err:
4370
 
                trace.mutter("Incompatible delta: %s", err.msg)
4371
 
                raise errors.IncompatibleRevision(self.target_repo._format)
4372
 
            basis_id, new_id, rich_root, tree_refs, inv_delta = parse_result
4373
 
            revision_id = new_id
4374
 
            parents = [key[0] for key in record.parents]
4375
 
            self.target_repo.add_inventory_by_delta(
4376
 
                basis_id, inv_delta, revision_id, parents)
4377
 
 
4378
3777
    def _extract_and_insert_inventories(self, substream, serializer,
4379
3778
            parse_delta=None):
4380
3779
        """Generate a new inventory versionedfile in target, converting data.
4385
3784
        target_rich_root = self.target_repo._format.rich_root_data
4386
3785
        target_tree_refs = self.target_repo._format.supports_tree_reference
4387
3786
        for record in substream:
 
3787
            if record.storage_kind == 'inventory-delta':
 
3788
                # Insert the delta directly
 
3789
                delta_tuple = record.get_bytes_as('inventory-delta')
 
3790
                basis_id, new_id, inv_delta, format_flags = delta_tuple
 
3791
                # Make sure the delta is compatible with the target
 
3792
                if format_flags[0] and not target_rich_root:
 
3793
                    raise errors.IncompatibleRevision(self.target_repo._format)
 
3794
                if format_flags[1] and not target_tree_refs:
 
3795
                    raise errors.IncompatibleRevision(self.target_repo._format)
 
3796
                revision_id = new_id[0]
 
3797
                parents = [key[0] for key in record.parents]
 
3798
                self.target_repo.add_inventory_by_delta(
 
3799
                    basis_id, inv_delta, revision_id, parents)
 
3800
                continue
4388
3801
            # It's not a delta, so it must be a fulltext in the source
4389
3802
            # serializer's format.
4390
3803
            bytes = record.get_bytes_as('fulltext')
4453
3866
        fetching the inventory weave.
4454
3867
        """
4455
3868
        if self._rich_root_upgrade():
4456
 
            return _mod_fetch.Inter1and2Helper(
 
3869
            import bzrlib.fetch
 
3870
            return bzrlib.fetch.Inter1and2Helper(
4457
3871
                self.from_repository).generate_root_texts(revs)
4458
3872
        else:
4459
3873
            return []
4462
3876
        phase = 'file'
4463
3877
        revs = search.get_keys()
4464
3878
        graph = self.from_repository.get_graph()
4465
 
        revs = tsort.topo_sort(graph.get_parent_map(revs))
 
3879
        revs = list(graph.iter_topo_order(revs))
4466
3880
        data_to_fetch = self.from_repository.item_keys_introduced_by(revs)
4467
3881
        text_keys = []
4468
3882
        for knit_kind, file_id, revisions in data_to_fetch:
4535
3949
                # Some missing keys are genuinely ghosts, filter those out.
4536
3950
                present = self.from_repository.inventories.get_parent_map(keys)
4537
3951
                revs = [key[0] for key in present]
 
3952
                # As with the original stream, we may need to generate root
 
3953
                # texts for the inventories we're about to stream.
 
3954
                for _ in self._generate_root_texts(revs):
 
3955
                    yield _
4538
3956
                # Get the inventory stream more-or-less as we do for the
4539
3957
                # original stream; there's no reason to assume that records
4540
3958
                # direct from the source will be suitable for the sink.  (Think
4569
3987
            from_format.network_name() == self.to_format.network_name()):
4570
3988
            raise AssertionError(
4571
3989
                "this case should be handled by GroupCHKStreamSource")
4572
 
        elif 'forceinvdeltas' in debug.debug_flags:
4573
 
            return self._get_convertable_inventory_stream(revision_ids,
4574
 
                    delta_versus_null=missing)
4575
 
        elif from_format.network_name() == self.to_format.network_name():
4576
 
            # Same format.
4577
 
            return self._get_simple_inventory_stream(revision_ids,
4578
 
                    missing=missing)
4579
 
        elif (not from_format.supports_chks and not self.to_format.supports_chks
4580
 
                and from_format._serializer == self.to_format._serializer):
4581
 
            # Essentially the same format.
 
3990
        elif (not from_format.supports_chks):
 
3991
            # Source repository doesn't support chks. So we can transmit the
 
3992
            # inventories 'as-is' and either they are just accepted on the
 
3993
            # target, or the Sink will properly convert it.
 
3994
            # (XXX: this assumes that all non-chk formats are understood as-is
 
3995
            # by any Sink, but that presumably isn't true for foreign repo
 
3996
            # formats added by bzr-svn etc?)
4582
3997
            return self._get_simple_inventory_stream(revision_ids,
4583
3998
                    missing=missing)
4584
3999
        else:
4585
 
            # Any time we switch serializations, we want to use an
4586
 
            # inventory-delta based approach.
 
4000
            # Make chk->non-chk (and chk with different serializers) fetch:
 
4001
            # copy the inventories as (format-neutral) inventory deltas.
4587
4002
            return self._get_convertable_inventory_stream(revision_ids,
4588
 
                    delta_versus_null=missing)
 
4003
                    fulltexts=missing)
4589
4004
 
4590
4005
    def _get_simple_inventory_stream(self, revision_ids, missing=False):
4591
4006
        # NB: This currently reopens the inventory weave in source;
4599
4014
            [(rev_id,) for rev_id in revision_ids],
4600
4015
            self.inventory_fetch_order(), delta_closure))
4601
4016
 
4602
 
    def _get_convertable_inventory_stream(self, revision_ids,
4603
 
                                          delta_versus_null=False):
4604
 
        # The two formats are sufficiently different that there is no fast
4605
 
        # path, so we need to send just inventorydeltas, which any
4606
 
        # sufficiently modern client can insert into any repository.
4607
 
        # The StreamSink code expects to be able to
 
4017
    def _get_convertable_inventory_stream(self, revision_ids, fulltexts=False):
 
4018
        # The source is using CHKs, but the target either doesn't or is has a
 
4019
        # different serializer.  The StreamSink code expects to be able to
4608
4020
        # 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,
 
4021
        # be converted.  That means inventory deltas (if the remote is <1.18,
4610
4022
        # RemoteStreamSink will fallback to VFS to insert the deltas).
4611
 
        yield ('inventory-deltas',
4612
 
           self._stream_invs_as_deltas(revision_ids,
4613
 
                                       delta_versus_null=delta_versus_null))
4614
 
 
4615
 
    def _stream_invs_as_deltas(self, revision_ids, delta_versus_null=False):
4616
 
        """Return a stream of inventory-deltas for the given rev ids.
4617
 
 
4618
 
        :param revision_ids: The list of inventories to transmit
4619
 
        :param delta_versus_null: Don't try to find a minimal delta for this
4620
 
            entry, instead compute the delta versus the NULL_REVISION. This
4621
 
            effectively streams a complete inventory. Used for stuff like
4622
 
            filling in missing parents, etc.
4623
 
        """
 
4023
        yield ('inventories',
 
4024
           self._stream_invs_as_deltas(revision_ids, fulltexts=fulltexts))
 
4025
 
 
4026
    def _stream_invs_as_deltas(self, revision_ids, fulltexts=False):
4624
4027
        from_repo = self.from_repository
4625
4028
        revision_keys = [(rev_id,) for rev_id in revision_ids]
4626
4029
        parent_map = from_repo.inventories.get_parent_map(revision_keys)
4628
4031
        # method...
4629
4032
        inventories = self.from_repository.iter_inventories(
4630
4033
            revision_ids, 'topological')
 
4034
        # XXX: ideally these flags would be per-revision, not per-repo (e.g.
 
4035
        # streaming a non-rich-root revision out of a rich-root repo back into
 
4036
        # a non-rich-root repo ought to be allowed)
4631
4037
        format = from_repo._format
 
4038
        flags = (format.rich_root_data, format.supports_tree_reference)
4632
4039
        invs_sent_so_far = set([_mod_revision.NULL_REVISION])
4633
 
        inventory_cache = lru_cache.LRUCache(50)
4634
 
        null_inventory = from_repo.revision_tree(
4635
 
            _mod_revision.NULL_REVISION).inventory
4636
 
        # XXX: ideally the rich-root/tree-refs flags would be per-revision, not
4637
 
        # per-repo (e.g.  streaming a non-rich-root revision out of a rich-root
4638
 
        # repo back into a non-rich-root repo ought to be allowed)
4639
 
        serializer = inventory_delta.InventoryDeltaSerializer(
4640
 
            versioned_root=format.rich_root_data,
4641
 
            tree_references=format.supports_tree_reference)
4642
4040
        for inv in inventories:
4643
4041
            key = (inv.revision_id,)
4644
 
            parent_keys = parent_map.get(key, ())
4645
 
            delta = None
4646
 
            if not delta_versus_null and parent_keys:
4647
 
                # The caller did not ask for complete inventories and we have
4648
 
                # some parents that we can delta against.  Make a delta against
4649
 
                # each parent so that we can find the smallest.
4650
 
                parent_ids = [parent_key[0] for parent_key in parent_keys]
 
4042
            parents = parent_map.get(key, ())
 
4043
            if fulltexts or parents == ():
 
4044
                # Either the caller asked for fulltexts, or there is no parent,
 
4045
                # so, stream as a delta from null:.
 
4046
                basis_id = _mod_revision.NULL_REVISION
 
4047
                parent_inv = Inventory(None)
 
4048
                delta = inv._make_delta(parent_inv)
 
4049
            else:
 
4050
                # Make a delta against each parent so that we can find the
 
4051
                # smallest.
 
4052
                best_delta = None
 
4053
                parent_ids = [parent_key[0] for parent_key in parents]
 
4054
                parent_ids.append(_mod_revision.NULL_REVISION)
4651
4055
                for parent_id in parent_ids:
4652
4056
                    if parent_id not in invs_sent_so_far:
4653
4057
                        # We don't know that the remote side has this basis, so
4654
4058
                        # we can't use it.
4655
4059
                        continue
4656
4060
                    if parent_id == _mod_revision.NULL_REVISION:
4657
 
                        parent_inv = null_inventory
 
4061
                        parent_inv = Inventory(None)
4658
4062
                    else:
4659
 
                        parent_inv = inventory_cache.get(parent_id, None)
4660
 
                        if parent_inv is None:
4661
 
                            parent_inv = from_repo.get_inventory(parent_id)
 
4063
                        parent_inv = from_repo.get_inventory(parent_id)
4662
4064
                    candidate_delta = inv._make_delta(parent_inv)
4663
 
                    if (delta is None or
4664
 
                        len(delta) > len(candidate_delta)):
4665
 
                        delta = candidate_delta
 
4065
                    if (best_delta is None or
 
4066
                        len(best_delta) > len(candidate_delta)):
 
4067
                        best_delta = candidate_delta
4666
4068
                        basis_id = parent_id
4667
 
            if delta is None:
4668
 
                # Either none of the parents ended up being suitable, or we
4669
 
                # were asked to delta against NULL
4670
 
                basis_id = _mod_revision.NULL_REVISION
4671
 
                delta = inv._make_delta(null_inventory)
4672
 
            invs_sent_so_far.add(inv.revision_id)
4673
 
            inventory_cache[inv.revision_id] = inv
4674
 
            delta_serialized = ''.join(
4675
 
                serializer.delta_to_lines(basis_id, key[-1], delta))
4676
 
            yield versionedfile.FulltextContentFactory(
4677
 
                key, parent_keys, None, delta_serialized)
 
4069
                delta = best_delta
 
4070
            invs_sent_so_far.add(basis_id)
 
4071
            yield versionedfile.InventoryDeltaContentFactory(
 
4072
                key, parents, None, delta, basis_id, flags, from_repo)
4678
4073
 
4679
4074
 
4680
4075
def _iter_for_revno(repo, partial_history_cache, stop_index=None,