/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: Martin Pool
  • Date: 2009-08-06 05:20:04 UTC
  • mto: This revision was merged to the branch mainline in revision 4595.
  • Revision ID: mbp@sourcefrog.net-20090806052004-22edm2oradkpm0xk
bundle_info blackbox test passes on rich-root formats

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,
33
32
    graph,
34
33
    inventory,
35
 
    inventory_delta,
36
34
    lazy_regex,
37
35
    lockable_files,
38
36
    lockdir,
39
37
    lru_cache,
40
38
    osutils,
41
39
    revision as _mod_revision,
42
 
    static_tuple,
43
40
    symbol_versioning,
44
 
    trace,
45
41
    tsort,
46
42
    ui,
47
43
    versionedfile,
52
48
from bzrlib.testament import Testament
53
49
""")
54
50
 
55
 
from bzrlib import (
56
 
    errors,
57
 
    registry,
58
 
    )
59
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
51
from bzrlib.decorators import needs_read_lock, needs_write_lock
60
52
from bzrlib.inter import InterObject
61
53
from bzrlib.inventory import (
62
54
    Inventory,
64
56
    ROOT_ID,
65
57
    entry_factory,
66
58
    )
67
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
59
from bzrlib import registry
68
60
from bzrlib.trace import (
69
61
    log_exception_quietly, note, mutter, mutter_callsite, warning)
70
62
 
73
65
_deprecation_warning_done = False
74
66
 
75
67
 
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
68
class CommitBuilder(object):
85
69
    """Provides an interface to build up a commit.
86
70
 
220
204
            # an inventory delta was accumulated without creating a new
221
205
            # inventory.
222
206
            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(
 
207
            self.inv_sha1 = self.repository.add_inventory_by_delta(
227
208
                basis_id, self._basis_delta, self._new_revision_id,
228
209
                self.parents)
229
210
        else:
483
464
            if content_summary[2] is None:
484
465
                raise ValueError("Files must not have executable = None")
485
466
            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:
 
467
                if (# if the file length changed we have to store:
 
468
                    parent_entry.text_size != content_summary[1] or
 
469
                    # if the exec bit has changed we have to store:
489
470
                    parent_entry.executable != content_summary[2]):
490
471
                    store = True
491
472
                elif parent_entry.text_sha1 == content_summary[3]:
558
539
                ie.revision = parent_entry.revision
559
540
                return self._get_delta(ie, basis_inv, path), False, None
560
541
            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
542
            self._add_text_to_weave(ie.file_id, '', heads, None)
565
543
        else:
566
544
            raise NotImplementedError('unknown kind')
828
806
                seen_root = True
829
807
        self.new_inventory = None
830
808
        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
809
            self._any_changes = True
835
810
        if not seen_root:
836
811
            # housekeeping root entry changes do not affect no-change commits.
870
845
        # versioned roots do not change unless the tree found a change.
871
846
 
872
847
 
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
848
######################################################################
891
849
# Repositories
892
850
 
893
851
 
894
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
852
class Repository(object):
895
853
    """Repository holding history for one or more branches.
896
854
 
897
855
    The repository holds and retrieves historical information including
966
924
        """
967
925
        if self._write_group is not self.get_transaction():
968
926
            # has an unlock or relock occured ?
969
 
            if suppress_errors:
970
 
                mutter(
971
 
                '(suppressed) mismatched lock context and write group. %r, %r',
972
 
                self._write_group, self.get_transaction())
973
 
                return
974
927
            raise errors.BzrError(
975
928
                'mismatched lock context and write group. %r, %r' %
976
929
                (self._write_group, self.get_transaction()))
1055
1008
 
1056
1009
        :seealso: add_inventory, for the contract.
1057
1010
        """
1058
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1011
        inv_lines = self._serialise_inventory_to_lines(inv)
1059
1012
        return self._inventory_add_lines(revision_id, parents,
1060
1013
            inv_lines, check_content=False)
1061
1014
 
1110
1063
        check_content=True):
1111
1064
        """Store lines in inv_vf and return the sha1 of the inventory."""
1112
1065
        parents = [(parent,) for parent in parents]
1113
 
        result = self.inventories.add_lines((revision_id,), parents, lines,
 
1066
        return self.inventories.add_lines((revision_id,), parents, lines,
1114
1067
            check_content=check_content)[0]
1115
 
        self.inventories._access.flush()
1116
 
        return result
1117
1068
 
1118
1069
    def add_revision(self, revision_id, rev, inv=None, config=None):
1119
1070
        """Add rev to the revision store as revision_id.
1257
1208
                    for record in getattr(self, kind).check(keys=keys[kind]):
1258
1209
                        if record.storage_kind == 'absent':
1259
1210
                            checker._report_items.append(
1260
 
                                'Missing %s {%s}' % (kind, record.key,))
 
1211
                                'Missing inventory {%s}' % (record.key,))
1261
1212
                        else:
1262
1213
                            last_object = self._check_record(kind, record,
1263
1214
                                checker, last_object, current_keys[(kind,) + record.key])
1268
1219
        """Check a single text from this repository."""
1269
1220
        if kind == 'inventories':
1270
1221
            rev_id = record.key[0]
1271
 
            inv = self._deserialise_inventory(rev_id,
 
1222
            inv = self.deserialise_inventory(rev_id,
1272
1223
                record.get_bytes_as('fulltext'))
1273
1224
            if last_object is not None:
1274
1225
                delta = inv._make_delta(last_object)
1318
1269
 
1319
1270
        :param _format: The format of the repository on disk.
1320
1271
        :param a_bzrdir: The BzrDir of the repository.
 
1272
 
 
1273
        In the future we will have a single api for all stores for
 
1274
        getting file texts, inventories and revisions, then
 
1275
        this construct will accept instances of those things.
1321
1276
        """
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
1277
        super(Repository, self).__init__()
1326
1278
        self._format = _format
1327
1279
        # the following are part of the public API for Repository:
1333
1285
        self._reconcile_does_inventory_gc = True
1334
1286
        self._reconcile_fixes_text_parents = False
1335
1287
        self._reconcile_backsup_inventory = True
 
1288
        # not right yet - should be more semantically clear ?
 
1289
        #
 
1290
        # TODO: make sure to construct the right store classes, etc, depending
 
1291
        # on whether escaping is required.
 
1292
        self._warn_if_deprecated()
1336
1293
        self._write_group = None
1337
1294
        # Additional places to query for data.
1338
1295
        self._fallback_repositories = []
1339
1296
        # An InventoryEntry cache, used during deserialization
1340
1297
        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
1298
 
1353
1299
    def __repr__(self):
1354
1300
        if self._fallback_repositories:
1403
1349
        data during reads, and allows a 'write_group' to be obtained. Write
1404
1350
        groups must be used for actual data insertion.
1405
1351
 
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
1352
        :param token: if this is already locked, then lock_write will fail
1413
1353
            unless the token matches the existing lock.
1414
1354
        :returns: a token if this instance supports tokens, otherwise None.
1417
1357
        :raises MismatchedToken: if the specified token doesn't match the token
1418
1358
            of the existing lock.
1419
1359
        :seealso: start_write_group.
1420
 
        :return: A RepositoryWriteLockResult.
 
1360
 
 
1361
        A token should be passed in if you know that you have locked the object
 
1362
        some other way, and need to synchronise this object's state with that
 
1363
        fact.
 
1364
 
 
1365
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1421
1366
        """
1422
1367
        locked = self.is_locked()
1423
 
        token = self.control_files.lock_write(token=token)
 
1368
        result = self.control_files.lock_write(token=token)
1424
1369
        if not locked:
1425
 
            self._warn_if_deprecated()
1426
 
            self._note_lock('w')
1427
1370
            for repo in self._fallback_repositories:
1428
1371
                # Writes don't affect fallback repos
1429
1372
                repo.lock_read()
1430
1373
            self._refresh_data()
1431
 
        return RepositoryWriteLockResult(self.unlock, token)
 
1374
        return result
1432
1375
 
1433
1376
    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
1377
        locked = self.is_locked()
1440
1378
        self.control_files.lock_read()
1441
1379
        if not locked:
1442
 
            self._warn_if_deprecated()
1443
 
            self._note_lock('r')
1444
1380
            for repo in self._fallback_repositories:
1445
1381
                repo.lock_read()
1446
1382
            self._refresh_data()
1447
 
        return LogicalLockResult(self.unlock)
1448
1383
 
1449
1384
    def get_physical_lock_status(self):
1450
1385
        return self.control_files.get_physical_lock_status()
1510
1445
 
1511
1446
        # now gather global repository information
1512
1447
        # XXX: This is available for many repos regardless of listability.
1513
 
        if self.user_transport.listable():
 
1448
        if self.bzrdir.root_transport.listable():
1514
1449
            # XXX: do we want to __define len__() ?
1515
1450
            # Maybe the versionedfiles object should provide a different
1516
1451
            # method to get the number of keys.
1526
1461
        :param using: If True, list only branches using this repository.
1527
1462
        """
1528
1463
        if using and not self.is_shared():
1529
 
            return self.bzrdir.list_branches()
 
1464
            try:
 
1465
                return [self.bzrdir.open_branch()]
 
1466
            except errors.NotBranchError:
 
1467
                return []
1530
1468
        class Evaluator(object):
1531
1469
 
1532
1470
            def __init__(self):
1541
1479
                    except errors.NoRepositoryPresent:
1542
1480
                        pass
1543
1481
                    else:
1544
 
                        return False, ([], repository)
 
1482
                        return False, (None, repository)
1545
1483
                self.first_call = False
1546
 
                value = (bzrdir.list_branches(), None)
 
1484
                try:
 
1485
                    value = (bzrdir.open_branch(), None)
 
1486
                except errors.NotBranchError:
 
1487
                    value = (None, None)
1547
1488
                return True, value
1548
1489
 
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)
 
1490
        branches = []
 
1491
        for branch, repository in bzrdir.BzrDir.find_bzrdirs(
 
1492
                self.bzrdir.root_transport, evaluate=Evaluator()):
 
1493
            if branch is not None:
 
1494
                branches.append(branch)
1554
1495
            if not using and repository is not None:
1555
 
                ret.extend(repository.find_branches())
1556
 
        return ret
 
1496
                branches.extend(repository.find_branches())
 
1497
        return branches
1557
1498
 
1558
1499
    @needs_read_lock
1559
1500
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1588
1529
        """Commit the contents accrued within the current write group.
1589
1530
 
1590
1531
        :seealso: start_write_group.
1591
 
        
1592
 
        :return: it may return an opaque hint that can be passed to 'pack'.
1593
1532
        """
1594
1533
        if self._write_group is not self.get_transaction():
1595
1534
            # has an unlock or relock occured ?
1649
1588
        # but at the moment we're only checking for texts referenced by
1650
1589
        # inventories at the graph's edge.
1651
1590
        key_deps = self.revisions._index._key_dependencies
1652
 
        key_deps.satisfy_refs_for_keys(present_inventories)
 
1591
        key_deps.add_keys(present_inventories)
1653
1592
        referrers = frozenset(r[0] for r in key_deps.get_referrers())
1654
1593
        file_ids = self.fileids_altered_by_revision_ids(referrers)
1655
1594
        missing_texts = set()
1668
1607
        return missing_keys
1669
1608
 
1670
1609
    def refresh_data(self):
1671
 
        """Re-read any data needed to synchronise with disk.
 
1610
        """Re-read any data needed to to synchronise with disk.
1672
1611
 
1673
1612
        This method is intended to be called after another repository instance
1674
1613
        (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.
 
1614
        repository. It may not be called during a write group, but may be
 
1615
        called at any other time.
1680
1616
        """
 
1617
        if self.is_in_write_group():
 
1618
            raise errors.InternalBzrError(
 
1619
                "May not refresh_data while in a write group.")
1681
1620
        self._refresh_data()
1682
1621
 
1683
1622
    def resume_write_group(self, tokens):
1756
1695
        :param revprops: Optional dictionary of revision properties.
1757
1696
        :param revision_id: Optional revision id.
1758
1697
        """
1759
 
        if self._fallback_repositories:
1760
 
            raise errors.BzrError("Cannot commit from a lightweight checkout "
1761
 
                "to a stacked branch. See "
1762
 
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
1763
1698
        result = self._commit_builder_class(self, parents, config,
1764
1699
            timestamp, timezone, committer, revprops, revision_id)
1765
1700
        self.start_write_group()
1766
1701
        return result
1767
1702
 
1768
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1769
1703
    def unlock(self):
1770
1704
        if (self.control_files._lock_count == 1 and
1771
1705
            self.control_files._lock_mode == 'w'):
1937
1871
                rev = self._serializer.read_revision_from_string(text)
1938
1872
                yield (revid, rev)
1939
1873
 
 
1874
    @needs_read_lock
 
1875
    def get_revision_xml(self, revision_id):
 
1876
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1877
        #       would have already do it.
 
1878
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1879
        # TODO: this can't just be replaced by:
 
1880
        # return self._serializer.write_revision_to_string(
 
1881
        #     self.get_revision(revision_id))
 
1882
        # as cStringIO preservers the encoding unlike write_revision_to_string
 
1883
        # or some other call down the path.
 
1884
        rev = self.get_revision(revision_id)
 
1885
        rev_tmp = cStringIO.StringIO()
 
1886
        # the current serializer..
 
1887
        self._serializer.write_revision(rev, rev_tmp)
 
1888
        rev_tmp.seek(0)
 
1889
        return rev_tmp.getvalue()
 
1890
 
1940
1891
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1941
1892
        """Produce a generator of revision deltas.
1942
1893
 
2184
2135
        """
2185
2136
        selected_keys = set((revid,) for revid in revision_ids)
2186
2137
        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)
 
2138
        pb = ui.ui_factory.nested_progress_bar()
 
2139
        try:
 
2140
            return self._find_file_ids_from_xml_inventory_lines(
 
2141
                w.iter_lines_added_or_present_in_keys(
 
2142
                    selected_keys, pb=pb),
 
2143
                selected_keys)
 
2144
        finally:
 
2145
            pb.finished()
2191
2146
 
2192
2147
    def iter_files_bytes(self, desired_files):
2193
2148
        """Iterate through file versions.
2354
2309
        num_file_ids = len(file_ids)
2355
2310
        for file_id, altered_versions in file_ids.iteritems():
2356
2311
            if pb is not None:
2357
 
                pb.update("Fetch texts", count, num_file_ids)
 
2312
                pb.update("fetch texts", count, num_file_ids)
2358
2313
            count += 1
2359
2314
            yield ("file", file_id, altered_versions)
2360
2315
 
2381
2336
        """Get Inventory object by revision id."""
2382
2337
        return self.iter_inventories([revision_id]).next()
2383
2338
 
2384
 
    def iter_inventories(self, revision_ids, ordering=None):
 
2339
    def iter_inventories(self, revision_ids):
2385
2340
        """Get many inventories by revision_ids.
2386
2341
 
2387
2342
        This will buffer some or all of the texts used in constructing the
2389
2344
        time.
2390
2345
 
2391
2346
        :param revision_ids: The expected revision ids of the inventories.
2392
 
        :param ordering: optional ordering, e.g. 'topological'.  If not
2393
 
            specified, the order of revision_ids will be preserved (by
2394
 
            buffering if necessary).
2395
2347
        :return: An iterator of inventories.
2396
2348
        """
2397
2349
        if ((None in revision_ids)
2398
2350
            or (_mod_revision.NULL_REVISION in revision_ids)):
2399
2351
            raise ValueError('cannot get null revision inventory')
2400
 
        return self._iter_inventories(revision_ids, ordering)
 
2352
        return self._iter_inventories(revision_ids)
2401
2353
 
2402
 
    def _iter_inventories(self, revision_ids, ordering):
 
2354
    def _iter_inventories(self, revision_ids):
2403
2355
        """single-document based inventory iteration."""
2404
 
        inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2405
 
        for text, revision_id in inv_xmls:
2406
 
            yield self._deserialise_inventory(revision_id, text)
 
2356
        for text, revision_id in self._iter_inventory_xmls(revision_ids):
 
2357
            yield self.deserialise_inventory(revision_id, text)
2407
2358
 
2408
 
    def _iter_inventory_xmls(self, revision_ids, ordering):
2409
 
        if ordering is None:
2410
 
            order_as_requested = True
2411
 
            ordering = 'unordered'
2412
 
        else:
2413
 
            order_as_requested = False
 
2359
    def _iter_inventory_xmls(self, revision_ids):
2414
2360
        keys = [(revision_id,) for revision_id in revision_ids]
2415
 
        if not keys:
2416
 
            return
2417
 
        if order_as_requested:
2418
 
            key_iter = iter(keys)
2419
 
            next_key = key_iter.next()
2420
 
        stream = self.inventories.get_record_stream(keys, ordering, True)
 
2361
        stream = self.inventories.get_record_stream(keys, 'unordered', True)
2421
2362
        text_chunks = {}
2422
2363
        for record in stream:
2423
2364
            if record.storage_kind != 'absent':
2424
 
                chunks = record.get_bytes_as('chunked')
2425
 
                if order_as_requested:
2426
 
                    text_chunks[record.key] = chunks
2427
 
                else:
2428
 
                    yield ''.join(chunks), record.key[-1]
 
2365
                text_chunks[record.key] = record.get_bytes_as('chunked')
2429
2366
            else:
2430
2367
                raise errors.NoSuchRevision(self, record.key)
2431
 
            if order_as_requested:
2432
 
                # Yield as many results as we can while preserving order.
2433
 
                while next_key in text_chunks:
2434
 
                    chunks = text_chunks.pop(next_key)
2435
 
                    yield ''.join(chunks), next_key[-1]
2436
 
                    try:
2437
 
                        next_key = key_iter.next()
2438
 
                    except StopIteration:
2439
 
                        # We still want to fully consume the get_record_stream,
2440
 
                        # just in case it is not actually finished at this point
2441
 
                        next_key = None
2442
 
                        break
 
2368
        for key in keys:
 
2369
            chunks = text_chunks.pop(key)
 
2370
            yield ''.join(chunks), key[-1]
2443
2371
 
2444
 
    def _deserialise_inventory(self, revision_id, xml):
 
2372
    def deserialise_inventory(self, revision_id, xml):
2445
2373
        """Transform the xml into an inventory object.
2446
2374
 
2447
2375
        :param revision_id: The expected revision id of the inventory.
2448
2376
        :param xml: A serialised inventory.
2449
2377
        """
2450
2378
        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)
 
2379
                    entry_cache=self._inventory_entry_cache)
2453
2380
        if result.revision_id != revision_id:
2454
2381
            raise AssertionError('revision id mismatch %s != %s' % (
2455
2382
                result.revision_id, revision_id))
2456
2383
        return result
2457
2384
 
 
2385
    def serialise_inventory(self, inv):
 
2386
        return self._serializer.write_inventory_to_string(inv)
 
2387
 
 
2388
    def _serialise_inventory_to_lines(self, inv):
 
2389
        return self._serializer.write_inventory_to_lines(inv)
 
2390
 
2458
2391
    def get_serializer_format(self):
2459
2392
        return self._serializer.format_num
2460
2393
 
2461
2394
    @needs_read_lock
2462
 
    def _get_inventory_xml(self, revision_id):
2463
 
        """Get serialized inventory as a string."""
2464
 
        texts = self._iter_inventory_xmls([revision_id], 'unordered')
 
2395
    def get_inventory_xml(self, revision_id):
 
2396
        """Get inventory XML as a file object."""
 
2397
        texts = self._iter_inventory_xmls([revision_id])
2465
2398
        try:
2466
2399
            text, revision_id = texts.next()
2467
2400
        except StopIteration:
2468
2401
            raise errors.HistoryMissing(self, 'inventory', revision_id)
2469
2402
        return text
2470
2403
 
 
2404
    @needs_read_lock
 
2405
    def get_inventory_sha1(self, revision_id):
 
2406
        """Return the sha1 hash of the inventory entry
 
2407
        """
 
2408
        return self.get_revision(revision_id).inventory_sha1
 
2409
 
2471
2410
    def get_rev_id_for_revno(self, revno, known_pair):
2472
2411
        """Return the revision id of a revno, given a later (revno, revid)
2473
2412
        pair in the same history.
2524
2463
            else:
2525
2464
                next_id = parents[0]
2526
2465
 
 
2466
    @needs_read_lock
 
2467
    def get_revision_inventory(self, revision_id):
 
2468
        """Return inventory of a past revision."""
 
2469
        # TODO: Unify this with get_inventory()
 
2470
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
2471
        # must be the same as its revision, so this is trivial.
 
2472
        if revision_id is None:
 
2473
            # This does not make sense: if there is no revision,
 
2474
            # then it is the current tree inventory surely ?!
 
2475
            # and thus get_root_id() is something that looks at the last
 
2476
            # commit on the branch, and the get_root_id is an inventory check.
 
2477
            raise NotImplementedError
 
2478
            # return Inventory(self.get_root_id())
 
2479
        else:
 
2480
            return self.get_inventory(revision_id)
 
2481
 
2527
2482
    def is_shared(self):
2528
2483
        """Return True if this repository is flagged as a shared repository."""
2529
2484
        raise NotImplementedError(self.is_shared)
2563
2518
            return RevisionTree(self, Inventory(root_id=None),
2564
2519
                                _mod_revision.NULL_REVISION)
2565
2520
        else:
2566
 
            inv = self.get_inventory(revision_id)
 
2521
            inv = self.get_revision_inventory(revision_id)
2567
2522
            return RevisionTree(self, inv, revision_id)
2568
2523
 
2569
2524
    def revision_trees(self, revision_ids):
2622
2577
            keys = tsort.topo_sort(parent_map)
2623
2578
        return [None] + list(keys)
2624
2579
 
2625
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2580
    def pack(self, hint=None):
2626
2581
        """Compress the data within the repository.
2627
2582
 
2628
2583
        This operation only makes sense for some repository types. For other
2638
2593
            obtained from the result of commit_write_group(). Out of
2639
2594
            date hints are simply ignored, because concurrent operations
2640
2595
            can obsolete them rapidly.
2641
 
 
2642
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2643
 
            the pack operation.
2644
2596
        """
2645
2597
 
2646
2598
    def get_transaction(self):
2662
2614
        for ((revision_id,), parent_keys) in \
2663
2615
                self.revisions.get_parent_map(query_keys).iteritems():
2664
2616
            if parent_keys:
2665
 
                result[revision_id] = tuple([parent_revid
2666
 
                    for (parent_revid,) in parent_keys])
 
2617
                result[revision_id] = tuple(parent_revid
 
2618
                    for (parent_revid,) in parent_keys)
2667
2619
            else:
2668
2620
                result[revision_id] = (_mod_revision.NULL_REVISION,)
2669
2621
        return result
2671
2623
    def _make_parents_provider(self):
2672
2624
        return self
2673
2625
 
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
2626
    def get_graph(self, other_repository=None):
2684
2627
        """Return the graph walker for this repository format"""
2685
2628
        parents_provider = self._make_parents_provider()
2780
2723
        result.check(callback_refs)
2781
2724
        return result
2782
2725
 
2783
 
    def _warn_if_deprecated(self, branch=None):
 
2726
    def _warn_if_deprecated(self):
2784
2727
        global _deprecation_warning_done
2785
2728
        if _deprecation_warning_done:
2786
2729
            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
 
2730
        _deprecation_warning_done = True
 
2731
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
2732
                % (self._format, self.bzrdir.transport.base))
2799
2733
 
2800
2734
    def supports_rich_root(self):
2801
2735
        return self._format.rich_root_data
3082
3016
    # help), and for fetching when data won't have come from the same
3083
3017
    # compressor.
3084
3018
    pack_compresses = False
3085
 
    # Does the repository inventory storage understand references to trees?
3086
 
    supports_tree_reference = None
3087
 
    # Is the format experimental ?
3088
 
    experimental = False
3089
3019
 
3090
 
    def __repr__(self):
3091
 
        return "%s()" % self.__class__.__name__
 
3020
    def __str__(self):
 
3021
        return "<%s>" % self.__class__.__name__
3092
3022
 
3093
3023
    def __eq__(self, other):
3094
3024
        # format objects are generally stateless
3107
3037
        """
3108
3038
        try:
3109
3039
            transport = a_bzrdir.get_repository_transport(None)
3110
 
            format_string = transport.get_bytes("format")
 
3040
            format_string = transport.get("format").read()
3111
3041
            return format_registry.get(format_string)
3112
3042
        except errors.NoSuchFile:
3113
3043
            raise errors.NoRepositoryPresent(a_bzrdir)
3195
3125
        raise NotImplementedError(self.network_name)
3196
3126
 
3197
3127
    def check_conversion_target(self, target_format):
3198
 
        if self.rich_root_data and not target_format.rich_root_data:
3199
 
            raise errors.BadConversionTarget(
3200
 
                'Does not support rich root data.', target_format,
3201
 
                from_format=self)
3202
 
        if (self.supports_tree_reference and 
3203
 
            not getattr(target_format, 'supports_tree_reference', False)):
3204
 
            raise errors.BadConversionTarget(
3205
 
                'Does not support nested trees', target_format,
3206
 
                from_format=self)
 
3128
        raise NotImplementedError(self.check_conversion_target)
3207
3129
 
3208
3130
    def open(self, a_bzrdir, _found=False):
3209
3131
        """Return an instance of this format for the bzrdir a_bzrdir.
3212
3134
        """
3213
3135
        raise NotImplementedError(self.open)
3214
3136
 
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
3137
 
3225
3138
class MetaDirRepositoryFormat(RepositoryFormat):
3226
3139
    """Common base class for the new repositories using the metadir layout."""
3431
3344
 
3432
3345
        :param revision_id: if None all content is copied, if NULL_REVISION no
3433
3346
                            content is copied.
3434
 
        :param pb: ignored.
 
3347
        :param pb: optional progress bar to use for progress reports. If not
 
3348
                   provided a default one will be created.
3435
3349
        :return: None.
3436
3350
        """
3437
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3438
3351
        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
3352
        f = RepoFetcher(to_repository=self.target,
3445
3353
                               from_repository=self.source,
3446
3354
                               last_revision=revision_id,
3447
3355
                               fetch_spec=fetch_spec,
3448
 
                               find_ghosts=find_ghosts)
 
3356
                               pb=pb, find_ghosts=find_ghosts)
3449
3357
 
3450
3358
    def _walk_to_common_revisions(self, revision_ids):
3451
3359
        """Walk out from revision_ids in source to revisions target has.
3620
3528
                self.target.texts.insert_record_stream(
3621
3529
                    self.source.texts.get_record_stream(
3622
3530
                        self.source.texts.keys(), 'topological', False))
3623
 
                pb.update('Copying inventory', 0, 1)
 
3531
                pb.update('copying inventory', 0, 1)
3624
3532
                self.target.inventories.insert_record_stream(
3625
3533
                    self.source.inventories.get_record_stream(
3626
3534
                        self.source.inventories.keys(), 'topological', False))
3752
3660
        # This is redundant with format.check_conversion_target(), however that
3753
3661
        # raises an exception, and we just want to say "False" as in we won't
3754
3662
        # support converting between these formats.
3755
 
        if 'IDS_never' in debug.debug_flags:
3756
 
            return False
3757
3663
        if source.supports_rich_root() and not target.supports_rich_root():
3758
3664
            return False
3759
3665
        if (source._format.supports_tree_reference
3760
3666
            and not target._format.supports_tree_reference):
3761
3667
            return False
3762
 
        if target._fallback_repositories and target._format.supports_chks:
3763
 
            # IDS doesn't know how to copy CHKs for the parent inventories it
3764
 
            # adds to stacked repos.
3765
 
            return False
3766
 
        if 'IDS_always' in debug.debug_flags:
3767
 
            return True
3768
 
        # Only use this code path for local source and target.  IDS does far
3769
 
        # too much IO (both bandwidth and roundtrips) over a network.
3770
 
        if not source.bzrdir.transport.base.startswith('file:///'):
3771
 
            return False
3772
 
        if not target.bzrdir.transport.base.startswith('file:///'):
3773
 
            return False
3774
3668
        return True
3775
3669
 
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):
 
3670
    def _get_delta_for_revision(self, tree, parent_ids, basis_id, cache):
3794
3671
        """Get the best delta and base for this revision.
3795
3672
 
3796
3673
        :return: (basis_id, delta)
3797
3674
        """
 
3675
        possible_trees = [(parent_id, cache[parent_id])
 
3676
                          for parent_id in parent_ids
 
3677
                           if parent_id in cache]
 
3678
        if len(possible_trees) == 0:
 
3679
            # There either aren't any parents, or the parents aren't in the
 
3680
            # cache, so just use the last converted tree
 
3681
            possible_trees.append((basis_id, cache[basis_id]))
3798
3682
        deltas = []
3799
 
        # Generate deltas against each tree, to find the shortest.
3800
 
        texts_possibly_new_in_tree = set()
3801
3683
        for basis_id, basis_tree in possible_trees:
3802
3684
            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
3685
            deltas.append((len(delta), basis_id, delta))
3818
3686
        deltas.sort()
3819
3687
        return deltas[0][1:]
3820
3688
 
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):
 
3689
    def _get_parent_keys(self, root_key, parent_map):
 
3690
        """Get the parent keys for a given root id."""
 
3691
        root_id, rev_id = root_key
 
3692
        # Include direct parents of the revision, but only if they used
 
3693
        # the same root_id and are heads.
 
3694
        parent_keys = []
 
3695
        for parent_id in parent_map[rev_id]:
 
3696
            if parent_id == _mod_revision.NULL_REVISION:
 
3697
                continue
 
3698
            if parent_id not in self._revision_id_to_root_id:
 
3699
                # We probably didn't read this revision, go spend the
 
3700
                # extra effort to actually check
 
3701
                try:
 
3702
                    tree = self.source.revision_tree(parent_id)
 
3703
                except errors.NoSuchRevision:
 
3704
                    # Ghost, fill out _revision_id_to_root_id in case we
 
3705
                    # encounter this again.
 
3706
                    # But set parent_root_id to None since we don't really know
 
3707
                    parent_root_id = None
 
3708
                else:
 
3709
                    parent_root_id = tree.get_root_id()
 
3710
                self._revision_id_to_root_id[parent_id] = None
 
3711
            else:
 
3712
                parent_root_id = self._revision_id_to_root_id[parent_id]
 
3713
            if root_id == parent_root_id:
 
3714
                # With stacking we _might_ want to refer to a non-local
 
3715
                # revision, but this code path only applies when we have the
 
3716
                # full content available, so ghosts really are ghosts, not just
 
3717
                # the edge of local data.
 
3718
                parent_keys.append((parent_id,))
 
3719
            else:
 
3720
                # root_id may be in the parent anyway.
 
3721
                try:
 
3722
                    tree = self.source.revision_tree(parent_id)
 
3723
                except errors.NoSuchRevision:
 
3724
                    # ghost, can't refer to it.
 
3725
                    pass
 
3726
                else:
 
3727
                    try:
 
3728
                        parent_keys.append((tree.inventory[root_id].revision,))
 
3729
                    except errors.NoSuchId:
 
3730
                        # not in the tree
 
3731
                        pass
 
3732
        g = graph.Graph(self.source.revisions)
 
3733
        heads = g.heads(parent_keys)
 
3734
        selected_keys = []
 
3735
        for key in parent_keys:
 
3736
            if key in heads and key not in selected_keys:
 
3737
                selected_keys.append(key)
 
3738
        return tuple([(root_id,)+ key for key in selected_keys])
 
3739
 
 
3740
    def _new_root_data_stream(self, root_keys_to_create, parent_map):
 
3741
        for root_key in root_keys_to_create:
 
3742
            parent_keys = self._get_parent_keys(root_key, parent_map)
 
3743
            yield versionedfile.FulltextContentFactory(root_key,
 
3744
                parent_keys, None, '')
 
3745
 
 
3746
    def _fetch_batch(self, revision_ids, basis_id, cache):
3851
3747
        """Fetch across a few revisions.
3852
3748
 
3853
3749
        :param revision_ids: The revisions to copy
3854
3750
        :param basis_id: The revision_id of a tree that must be in cache, used
3855
3751
            as a basis for delta when no other base is available
3856
3752
        :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
3753
        :return: The revision_id of the last converted tree. The RevisionTree
3860
3754
            for it will be in cache
3861
3755
        """
3867
3761
        pending_deltas = []
3868
3762
        pending_revisions = []
3869
3763
        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
3764
        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
3765
            current_revision_id = tree.get_revision_id()
3876
3766
            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
3767
            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))
 
3768
                                                           basis_id, cache)
3888
3769
            if self._converting_to_rich_root:
3889
3770
                self._revision_id_to_root_id[current_revision_id] = \
3890
3771
                    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()
 
3772
            # Find text entries that need to be copied
3894
3773
            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)
 
3774
                if new_path is not None:
 
3775
                    if not new_path:
 
3776
                        # This is the root
 
3777
                        if not self.target.supports_rich_root():
 
3778
                            # The target doesn't support rich root, so we don't
 
3779
                            # copy
 
3780
                            continue
 
3781
                        if self._converting_to_rich_root:
 
3782
                            # This can't be copied normally, we have to insert
 
3783
                            # it specially
 
3784
                            root_keys_to_create.add((file_id, entry.revision))
 
3785
                            continue
 
3786
                    text_keys.add((file_id, entry.revision))
 
3787
            revision = self.source.get_revision(current_revision_id)
 
3788
            pending_deltas.append((basis_id, delta,
 
3789
                current_revision_id, revision.parent_ids))
3922
3790
            pending_revisions.append(revision)
3923
3791
            cache[current_revision_id] = tree
3924
3792
            basis_id = current_revision_id
3925
 
        self.source._safe_to_return_from_cache = False
3926
3793
        # Copy file texts
3927
3794
        from_texts = self.source.texts
3928
3795
        to_texts = self.target.texts
3929
3796
        if root_keys_to_create:
3930
 
            root_stream = _mod_fetch._new_root_data_stream(
3931
 
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3932
 
                self.source, graph=a_graph)
 
3797
            root_stream = self._new_root_data_stream(root_keys_to_create,
 
3798
                                                     parent_map)
3933
3799
            to_texts.insert_record_stream(root_stream)
3934
3800
        to_texts.insert_record_stream(from_texts.get_record_stream(
3935
3801
            text_keys, self.target._format._fetch_order,
3942
3808
            # for the new revisions that we are about to insert.  We do this
3943
3809
            # before adding the revisions so that no revision is added until
3944
3810
            # all the inventories it may depend on are added.
3945
 
            # Note that this is overzealous, as we may have fetched these in an
3946
 
            # earlier batch.
3947
3811
            parent_ids = set()
3948
3812
            revision_ids = set()
3949
3813
            for revision in pending_revisions:
3952
3816
            parent_ids.difference_update(revision_ids)
3953
3817
            parent_ids.discard(_mod_revision.NULL_REVISION)
3954
3818
            parent_map = self.source.get_parent_map(parent_ids)
3955
 
            # we iterate over parent_map and not parent_ids because we don't
3956
 
            # want to try copying any revision which is a ghost
3957
 
            for parent_tree in self.source.revision_trees(parent_map):
 
3819
            for parent_tree in self.source.revision_trees(parent_ids):
 
3820
                basis_id, delta = self._get_delta_for_revision(tree, parent_ids, basis_id, cache)
3958
3821
                current_revision_id = parent_tree.get_revision_id()
3959
3822
                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
 
                basis_id, delta = self._get_delta_for_revision(parent_tree,
3966
 
                    parents_parents, possible_trees)
3967
3823
                self.target.add_inventory_by_delta(
3968
3824
                    basis_id, delta, current_revision_id, parents_parents)
3969
3825
        # insert signatures and revisions
3992
3848
        cache[basis_id] = basis_tree
3993
3849
        del basis_tree # We don't want to hang on to it here
3994
3850
        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
3851
        for offset in range(0, len(revision_ids), batch_size):
4002
3852
            self.target.start_write_group()
4003
3853
            try:
4004
3854
                pb.update('Transferring revisions', offset,
4005
3855
                          len(revision_ids))
4006
3856
                batch = revision_ids[offset:offset+batch_size]
4007
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
4008
 
                                             a_graph=a_graph)
 
3857
                basis_id = self._fetch_batch(batch, basis_id, cache)
4009
3858
            except:
4010
 
                self.source._safe_to_return_from_cache = False
4011
3859
                self.target.abort_write_group()
4012
3860
                raise
4013
3861
            else:
4025
3873
        """See InterRepository.fetch()."""
4026
3874
        if fetch_spec is not None:
4027
3875
            raise AssertionError("Not implemented yet...")
4028
 
        ui.ui_factory.warn_experimental_format_fetch(self)
4029
3876
        if (not self.source.supports_rich_root()
4030
3877
            and self.target.supports_rich_root()):
4031
3878
            self._converting_to_rich_root = True
4032
3879
            self._revision_id_to_root_id = {}
4033
3880
        else:
4034
3881
            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
3882
        revision_ids = self.target.search_missing_revision_ids(self.source,
4041
3883
            revision_id, find_ghosts=find_ghosts).get_keys()
4042
3884
        if not revision_ids:
4048
3890
        # Walk though all revisions; get inventory deltas, copy referenced
4049
3891
        # texts that delta references, insert the delta, revision and
4050
3892
        # signature.
 
3893
        first_rev = self.source.get_revision(revision_ids[0])
4051
3894
        if pb is None:
4052
3895
            my_pb = ui.ui_factory.nested_progress_bar()
4053
3896
            pb = my_pb
4111
3954
        :param to_convert: The disk object to convert.
4112
3955
        :param pb: a progress bar to use for progress information.
4113
3956
        """
4114
 
        pb = ui.ui_factory.nested_progress_bar()
 
3957
        self.pb = pb
4115
3958
        self.count = 0
4116
3959
        self.total = 4
4117
3960
        # this is only useful with metadir layouts - separated repo content.
4118
3961
        # trigger an assertion if not such
4119
3962
        repo._format.get_format_string()
4120
3963
        self.repo_dir = repo.bzrdir
4121
 
        pb.update('Moving repository to repository.backup')
 
3964
        self.step('Moving repository to repository.backup')
4122
3965
        self.repo_dir.transport.move('repository', 'repository.backup')
4123
3966
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
4124
3967
        repo._format.check_conversion_target(self.target_format)
4125
3968
        self.source_repo = repo._format.open(self.repo_dir,
4126
3969
            _found=True,
4127
3970
            _override_transport=backup_transport)
4128
 
        pb.update('Creating new repository')
 
3971
        self.step('Creating new repository')
4129
3972
        converted = self.target_format.initialize(self.repo_dir,
4130
3973
                                                  self.source_repo.is_shared())
4131
3974
        converted.lock_write()
4132
3975
        try:
4133
 
            pb.update('Copying content')
 
3976
            self.step('Copying content into repository.')
4134
3977
            self.source_repo.copy_content_into(converted)
4135
3978
        finally:
4136
3979
            converted.unlock()
4137
 
        pb.update('Deleting old repository content')
 
3980
        self.step('Deleting old repository content.')
4138
3981
        self.repo_dir.transport.delete_tree('repository.backup')
4139
 
        ui.ui_factory.note('repository converted')
4140
 
        pb.finished()
 
3982
        self.pb.note('repository converted')
 
3983
 
 
3984
    def step(self, message):
 
3985
        """Update the pb by a step."""
 
3986
        self.count +=1
 
3987
        self.pb.update(message, self.count, self.total)
4141
3988
 
4142
3989
 
4143
3990
_unescape_map = {
4215
4062
        self.file_ids = set([file_id for file_id, _ in
4216
4063
            self.text_index.iterkeys()])
4217
4064
        # text keys is now grouped by file_id
 
4065
        n_weaves = len(self.file_ids)
 
4066
        files_in_revisions = {}
 
4067
        revisions_of_files = {}
4218
4068
        n_versions = len(self.text_index)
4219
4069
        progress_bar.update('loading text store', 0, n_versions)
4220
4070
        parent_map = self.repository.texts.get_parent_map(self.text_index)
4313
4163
            else:
4314
4164
                new_pack.set_write_cache_size(1024*1024)
4315
4165
        for substream_type, substream in stream:
4316
 
            if 'stream' in debug.debug_flags:
4317
 
                mutter('inserting substream: %s', substream_type)
4318
4166
            if substream_type == 'texts':
4319
4167
                self.target_repo.texts.insert_record_stream(substream)
4320
4168
            elif substream_type == 'inventories':
4324
4172
                else:
4325
4173
                    self._extract_and_insert_inventories(
4326
4174
                        substream, src_serializer)
4327
 
            elif substream_type == 'inventory-deltas':
4328
 
                self._extract_and_insert_inventory_deltas(
4329
 
                    substream, src_serializer)
4330
4175
            elif substream_type == 'chk_bytes':
4331
4176
                # XXX: This doesn't support conversions, as it assumes the
4332
4177
                #      conversion was done in the fetch code.
4363
4208
                ):
4364
4209
                if versioned_file is None:
4365
4210
                    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
4211
                missing_keys.update((prefix,) + key for key in
4374
4212
                    versioned_file.get_missing_compression_parent_keys())
4375
4213
        except NotImplementedError:
4390
4228
            self.target_repo.pack(hint=hint)
4391
4229
        return [], set()
4392
4230
 
4393
 
    def _extract_and_insert_inventory_deltas(self, substream, serializer):
4394
 
        target_rich_root = self.target_repo._format.rich_root_data
4395
 
        target_tree_refs = self.target_repo._format.supports_tree_reference
4396
 
        for record in substream:
4397
 
            # Insert the delta directly
4398
 
            inventory_delta_bytes = record.get_bytes_as('fulltext')
4399
 
            deserialiser = inventory_delta.InventoryDeltaDeserializer()
4400
 
            try:
4401
 
                parse_result = deserialiser.parse_text_bytes(
4402
 
                    inventory_delta_bytes)
4403
 
            except inventory_delta.IncompatibleInventoryDelta, err:
4404
 
                trace.mutter("Incompatible delta: %s", err.msg)
4405
 
                raise errors.IncompatibleRevision(self.target_repo._format)
4406
 
            basis_id, new_id, rich_root, tree_refs, inv_delta = parse_result
4407
 
            revision_id = new_id
4408
 
            parents = [key[0] for key in record.parents]
4409
 
            self.target_repo.add_inventory_by_delta(
4410
 
                basis_id, inv_delta, revision_id, parents)
4411
 
 
4412
 
    def _extract_and_insert_inventories(self, substream, serializer,
4413
 
            parse_delta=None):
 
4231
    def _extract_and_insert_inventories(self, substream, serializer):
4414
4232
        """Generate a new inventory versionedfile in target, converting data.
4415
4233
 
4416
4234
        The inventory is retrieved from the source, (deserializing it), and
4417
4235
        stored in the target (reserializing it in a different format).
4418
4236
        """
4419
 
        target_rich_root = self.target_repo._format.rich_root_data
4420
 
        target_tree_refs = self.target_repo._format.supports_tree_reference
4421
4237
        for record in substream:
4422
 
            # It's not a delta, so it must be a fulltext in the source
4423
 
            # serializer's format.
4424
4238
            bytes = record.get_bytes_as('fulltext')
4425
4239
            revision_id = record.key[0]
4426
4240
            inv = serializer.read_inventory_from_string(bytes, revision_id)
4427
4241
            parents = [key[0] for key in record.parents]
4428
4242
            self.target_repo.add_inventory(revision_id, inv, parents)
4429
 
            # No need to keep holding this full inv in memory when the rest of
4430
 
            # the substream is likely to be all deltas.
4431
 
            del inv
4432
4243
 
4433
4244
    def _extract_and_insert_revisions(self, substream, serializer):
4434
4245
        for record in substream:
4483
4294
        return [('signatures', signatures), ('revisions', revisions)]
4484
4295
 
4485
4296
    def _generate_root_texts(self, revs):
4486
 
        """This will be called by get_stream between fetching weave texts and
 
4297
        """This will be called by __fetch between fetching weave texts and
4487
4298
        fetching the inventory weave.
 
4299
 
 
4300
        Subclasses should override this if they need to generate root texts
 
4301
        after fetching weave texts.
4488
4302
        """
4489
4303
        if self._rich_root_upgrade():
4490
 
            return _mod_fetch.Inter1and2Helper(
 
4304
            import bzrlib.fetch
 
4305
            return bzrlib.fetch.Inter1and2Helper(
4491
4306
                self.from_repository).generate_root_texts(revs)
4492
4307
        else:
4493
4308
            return []
4496
4311
        phase = 'file'
4497
4312
        revs = search.get_keys()
4498
4313
        graph = self.from_repository.get_graph()
4499
 
        revs = tsort.topo_sort(graph.get_parent_map(revs))
 
4314
        revs = list(graph.iter_topo_order(revs))
4500
4315
        data_to_fetch = self.from_repository.item_keys_introduced_by(revs)
4501
4316
        text_keys = []
4502
4317
        for knit_kind, file_id, revisions in data_to_fetch:
4521
4336
                # will be valid.
4522
4337
                for _ in self._generate_root_texts(revs):
4523
4338
                    yield _
 
4339
                # NB: This currently reopens the inventory weave in source;
 
4340
                # using a single stream interface instead would avoid this.
 
4341
                from_weave = self.from_repository.inventories
4524
4342
                # we fetch only the referenced inventories because we do not
4525
4343
                # know for unselected inventories whether all their required
4526
4344
                # texts are present in the other repository - it could be
4565
4383
            if not keys:
4566
4384
                # No need to stream something we don't have
4567
4385
                continue
4568
 
            if substream_kind == 'inventories':
4569
 
                # Some missing keys are genuinely ghosts, filter those out.
4570
 
                present = self.from_repository.inventories.get_parent_map(keys)
4571
 
                revs = [key[0] for key in present]
4572
 
                # Get the inventory stream more-or-less as we do for the
4573
 
                # original stream; there's no reason to assume that records
4574
 
                # direct from the source will be suitable for the sink.  (Think
4575
 
                # e.g. 2a -> 1.9-rich-root).
4576
 
                for info in self._get_inventory_stream(revs, missing=True):
4577
 
                    yield info
4578
 
                continue
4579
 
 
4580
4386
            # Ask for full texts always so that we don't need more round trips
4581
4387
            # after this stream.
4582
4388
            # Some of the missing keys are genuinely ghosts, so filter absent
4597
4403
        return (not self.from_repository._format.rich_root_data and
4598
4404
            self.to_format.rich_root_data)
4599
4405
 
4600
 
    def _get_inventory_stream(self, revision_ids, missing=False):
 
4406
    def _get_inventory_stream(self, revision_ids):
4601
4407
        from_format = self.from_repository._format
4602
 
        if (from_format.supports_chks and self.to_format.supports_chks and
4603
 
            from_format.network_name() == self.to_format.network_name()):
4604
 
            raise AssertionError(
4605
 
                "this case should be handled by GroupCHKStreamSource")
4606
 
        elif 'forceinvdeltas' in debug.debug_flags:
4607
 
            return self._get_convertable_inventory_stream(revision_ids,
4608
 
                    delta_versus_null=missing)
4609
 
        elif from_format.network_name() == self.to_format.network_name():
4610
 
            # Same format.
4611
 
            return self._get_simple_inventory_stream(revision_ids,
4612
 
                    missing=missing)
4613
 
        elif (not from_format.supports_chks and not self.to_format.supports_chks
4614
 
                and from_format._serializer == self.to_format._serializer):
4615
 
            # Essentially the same format.
4616
 
            return self._get_simple_inventory_stream(revision_ids,
4617
 
                    missing=missing)
 
4408
        if (from_format.supports_chks and self.to_format.supports_chks
 
4409
            and (from_format._serializer == self.to_format._serializer)):
 
4410
            # Both sides support chks, and they use the same serializer, so it
 
4411
            # is safe to transmit the chk pages and inventory pages across
 
4412
            # as-is.
 
4413
            return self._get_chk_inventory_stream(revision_ids)
 
4414
        elif (not from_format.supports_chks):
 
4415
            # Source repository doesn't support chks. So we can transmit the
 
4416
            # inventories 'as-is' and either they are just accepted on the
 
4417
            # target, or the Sink will properly convert it.
 
4418
            return self._get_simple_inventory_stream(revision_ids)
4618
4419
        else:
4619
 
            # Any time we switch serializations, we want to use an
4620
 
            # inventory-delta based approach.
4621
 
            return self._get_convertable_inventory_stream(revision_ids,
4622
 
                    delta_versus_null=missing)
 
4420
            # XXX: Hack to make not-chk->chk fetch: copy the inventories as
 
4421
            #      inventories. Note that this should probably be done somehow
 
4422
            #      as part of bzrlib.repository.StreamSink. Except JAM couldn't
 
4423
            #      figure out how a non-chk repository could possibly handle
 
4424
            #      deserializing an inventory stream from a chk repo, as it
 
4425
            #      doesn't have a way to understand individual pages.
 
4426
            return self._get_convertable_inventory_stream(revision_ids)
4623
4427
 
4624
 
    def _get_simple_inventory_stream(self, revision_ids, missing=False):
4625
 
        # NB: This currently reopens the inventory weave in source;
4626
 
        # using a single stream interface instead would avoid this.
 
4428
    def _get_simple_inventory_stream(self, revision_ids):
4627
4429
        from_weave = self.from_repository.inventories
4628
 
        if missing:
4629
 
            delta_closure = True
4630
 
        else:
4631
 
            delta_closure = not self.delta_on_metadata()
4632
4430
        yield ('inventories', from_weave.get_record_stream(
4633
4431
            [(rev_id,) for rev_id in revision_ids],
4634
 
            self.inventory_fetch_order(), delta_closure))
4635
 
 
4636
 
    def _get_convertable_inventory_stream(self, revision_ids,
4637
 
                                          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
4642
 
        # convert on the target, so we need to put bytes-on-the-wire that can
4643
 
        # be converted.  That means inventory deltas (if the remote is <1.19,
4644
 
        # RemoteStreamSink will fallback to VFS to insert the deltas).
4645
 
        yield ('inventory-deltas',
4646
 
           self._stream_invs_as_deltas(revision_ids,
4647
 
                                       delta_versus_null=delta_versus_null))
4648
 
 
4649
 
    def _stream_invs_as_deltas(self, revision_ids, delta_versus_null=False):
4650
 
        """Return a stream of inventory-deltas for the given rev ids.
4651
 
 
4652
 
        :param revision_ids: The list of inventories to transmit
4653
 
        :param delta_versus_null: Don't try to find a minimal delta for this
4654
 
            entry, instead compute the delta versus the NULL_REVISION. This
4655
 
            effectively streams a complete inventory. Used for stuff like
4656
 
            filling in missing parents, etc.
4657
 
        """
 
4432
            self.inventory_fetch_order(),
 
4433
            not self.delta_on_metadata()))
 
4434
 
 
4435
    def _get_chk_inventory_stream(self, revision_ids):
 
4436
        """Fetch the inventory texts, along with the associated chk maps."""
 
4437
        # We want an inventory outside of the search set, so that we can filter
 
4438
        # out uninteresting chk pages. For now we use
 
4439
        # _find_revision_outside_set, but if we had a Search with cut_revs, we
 
4440
        # could use that instead.
 
4441
        start_rev_id = self.from_repository._find_revision_outside_set(
 
4442
                            revision_ids)
 
4443
        start_rev_key = (start_rev_id,)
 
4444
        inv_keys_to_fetch = [(rev_id,) for rev_id in revision_ids]
 
4445
        if start_rev_id != _mod_revision.NULL_REVISION:
 
4446
            inv_keys_to_fetch.append((start_rev_id,))
 
4447
        # Any repo that supports chk_bytes must also support out-of-order
 
4448
        # insertion. At least, that is how we expect it to work
 
4449
        # We use get_record_stream instead of iter_inventories because we want
 
4450
        # to be able to insert the stream as well. We could instead fetch
 
4451
        # allowing deltas, and then iter_inventories, but we don't know whether
 
4452
        # source or target is more 'local' anway.
 
4453
        inv_stream = self.from_repository.inventories.get_record_stream(
 
4454
            inv_keys_to_fetch, 'unordered',
 
4455
            True) # We need them as full-texts so we can find their references
 
4456
        uninteresting_chk_roots = set()
 
4457
        interesting_chk_roots = set()
 
4458
        def filter_inv_stream(inv_stream):
 
4459
            for idx, record in enumerate(inv_stream):
 
4460
                ### child_pb.update('fetch inv', idx, len(inv_keys_to_fetch))
 
4461
                bytes = record.get_bytes_as('fulltext')
 
4462
                chk_inv = inventory.CHKInventory.deserialise(
 
4463
                    self.from_repository.chk_bytes, bytes, record.key)
 
4464
                if record.key == start_rev_key:
 
4465
                    uninteresting_chk_roots.add(chk_inv.id_to_entry.key())
 
4466
                    p_id_map = chk_inv.parent_id_basename_to_file_id
 
4467
                    if p_id_map is not None:
 
4468
                        uninteresting_chk_roots.add(p_id_map.key())
 
4469
                else:
 
4470
                    yield record
 
4471
                    interesting_chk_roots.add(chk_inv.id_to_entry.key())
 
4472
                    p_id_map = chk_inv.parent_id_basename_to_file_id
 
4473
                    if p_id_map is not None:
 
4474
                        interesting_chk_roots.add(p_id_map.key())
 
4475
        ### pb.update('fetch inventory', 0, 2)
 
4476
        yield ('inventories', filter_inv_stream(inv_stream))
 
4477
        # Now that we have worked out all of the interesting root nodes, grab
 
4478
        # all of the interesting pages and insert them
 
4479
        ### pb.update('fetch inventory', 1, 2)
 
4480
        interesting = chk_map.iter_interesting_nodes(
 
4481
            self.from_repository.chk_bytes, interesting_chk_roots,
 
4482
            uninteresting_chk_roots)
 
4483
        def to_stream_adapter():
 
4484
            """Adapt the iter_interesting_nodes result to a single stream.
 
4485
 
 
4486
            iter_interesting_nodes returns records as it processes them, along
 
4487
            with keys. However, we only want to return the records themselves.
 
4488
            """
 
4489
            for record, items in interesting:
 
4490
                if record is not None:
 
4491
                    yield record
 
4492
        # XXX: We could instead call get_record_stream(records.keys())
 
4493
        #      ATM, this will always insert the records as fulltexts, and
 
4494
        #      requires that you can hang on to records once you have gone
 
4495
        #      on to the next one. Further, it causes the target to
 
4496
        #      recompress the data. Testing shows it to be faster than
 
4497
        #      requesting the records again, though.
 
4498
        yield ('chk_bytes', to_stream_adapter())
 
4499
        ### pb.update('fetch inventory', 2, 2)
 
4500
 
 
4501
    def _get_convertable_inventory_stream(self, revision_ids):
 
4502
        # XXX: One of source or target is using chks, and they don't have
 
4503
        #      compatible serializations. The StreamSink code expects to be
 
4504
        #      able to convert on the target, so we need to put
 
4505
        #      bytes-on-the-wire that can be converted
 
4506
        yield ('inventories', self._stream_invs_as_fulltexts(revision_ids))
 
4507
 
 
4508
    def _stream_invs_as_fulltexts(self, revision_ids):
4658
4509
        from_repo = self.from_repository
 
4510
        from_serializer = from_repo._format._serializer
4659
4511
        revision_keys = [(rev_id,) for rev_id in revision_ids]
4660
4512
        parent_map = from_repo.inventories.get_parent_map(revision_keys)
4661
 
        # XXX: possibly repos could implement a more efficient iter_inv_deltas
4662
 
        # method...
4663
 
        inventories = self.from_repository.iter_inventories(
4664
 
            revision_ids, 'topological')
4665
 
        format = from_repo._format
4666
 
        invs_sent_so_far = set([_mod_revision.NULL_REVISION])
4667
 
        inventory_cache = lru_cache.LRUCache(50)
4668
 
        null_inventory = from_repo.revision_tree(
4669
 
            _mod_revision.NULL_REVISION).inventory
4670
 
        # XXX: ideally the rich-root/tree-refs flags would be per-revision, not
4671
 
        # per-repo (e.g.  streaming a non-rich-root revision out of a rich-root
4672
 
        # repo back into a non-rich-root repo ought to be allowed)
4673
 
        serializer = inventory_delta.InventoryDeltaSerializer(
4674
 
            versioned_root=format.rich_root_data,
4675
 
            tree_references=format.supports_tree_reference)
4676
 
        for inv in inventories:
 
4513
        for inv in self.from_repository.iter_inventories(revision_ids):
 
4514
            # XXX: This is a bit hackish, but it works. Basically,
 
4515
            #      CHKSerializer 'accidentally' supports
 
4516
            #      read/write_inventory_to_string, even though that is never
 
4517
            #      the format that is stored on disk. It *does* give us a
 
4518
            #      single string representation for an inventory, so live with
 
4519
            #      it for now.
 
4520
            #      This would be far better if we had a 'serialized inventory
 
4521
            #      delta' form. Then we could use 'inventory._make_delta', and
 
4522
            #      transmit that. This would both be faster to generate, and
 
4523
            #      result in fewer bytes-on-the-wire.
 
4524
            as_bytes = from_serializer.write_inventory_to_string(inv)
4677
4525
            key = (inv.revision_id,)
4678
4526
            parent_keys = parent_map.get(key, ())
4679
 
            delta = None
4680
 
            if not delta_versus_null and parent_keys:
4681
 
                # The caller did not ask for complete inventories and we have
4682
 
                # some parents that we can delta against.  Make a delta against
4683
 
                # each parent so that we can find the smallest.
4684
 
                parent_ids = [parent_key[0] for parent_key in parent_keys]
4685
 
                for parent_id in parent_ids:
4686
 
                    if parent_id not in invs_sent_so_far:
4687
 
                        # We don't know that the remote side has this basis, so
4688
 
                        # we can't use it.
4689
 
                        continue
4690
 
                    if parent_id == _mod_revision.NULL_REVISION:
4691
 
                        parent_inv = null_inventory
4692
 
                    else:
4693
 
                        parent_inv = inventory_cache.get(parent_id, None)
4694
 
                        if parent_inv is None:
4695
 
                            parent_inv = from_repo.get_inventory(parent_id)
4696
 
                    candidate_delta = inv._make_delta(parent_inv)
4697
 
                    if (delta is None or
4698
 
                        len(delta) > len(candidate_delta)):
4699
 
                        delta = candidate_delta
4700
 
                        basis_id = parent_id
4701
 
            if delta is None:
4702
 
                # Either none of the parents ended up being suitable, or we
4703
 
                # were asked to delta against NULL
4704
 
                basis_id = _mod_revision.NULL_REVISION
4705
 
                delta = inv._make_delta(null_inventory)
4706
 
            invs_sent_so_far.add(inv.revision_id)
4707
 
            inventory_cache[inv.revision_id] = inv
4708
 
            delta_serialized = ''.join(
4709
 
                serializer.delta_to_lines(basis_id, key[-1], delta))
4710
4527
            yield versionedfile.FulltextContentFactory(
4711
 
                key, parent_keys, None, delta_serialized)
 
4528
                key, parent_keys, None, as_bytes)
4712
4529
 
4713
4530
 
4714
4531
def _iter_for_revno(repo, partial_history_cache, stop_index=None,