/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: Jelmer Vernooij
  • Date: 2011-03-13 21:30:33 UTC
  • mto: This revision was merged to the branch mainline in revision 5724.
  • Revision ID: jelmer@samba.org-20110313213033-ud9t11mm8e3idtti
Add test for per-file-timestamp zipfiles.

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-2011 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
25
25
    check,
26
26
    chk_map,
27
27
    config,
 
28
    controldir,
28
29
    debug,
29
30
    fetch as _mod_fetch,
30
31
    fifo_cache,
33
34
    graph,
34
35
    inventory,
35
36
    inventory_delta,
36
 
    lazy_regex,
37
37
    lockable_files,
38
38
    lockdir,
39
39
    lru_cache,
40
40
    osutils,
 
41
    pyutils,
41
42
    revision as _mod_revision,
42
43
    static_tuple,
43
 
    symbol_versioning,
44
44
    trace,
45
45
    tsort,
46
 
    ui,
47
46
    versionedfile,
48
47
    )
49
48
from bzrlib.bundle import serializer
55
54
from bzrlib import (
56
55
    errors,
57
56
    registry,
 
57
    symbol_versioning,
 
58
    ui,
58
59
    )
59
60
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
60
61
from bzrlib.inter import InterObject
64
65
    ROOT_ID,
65
66
    entry_factory,
66
67
    )
 
68
from bzrlib.recordcounter import RecordCounter
67
69
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
68
70
from bzrlib.trace import (
69
71
    log_exception_quietly, note, mutter, mutter_callsite, warning)
111
113
 
112
114
        if committer is None:
113
115
            self._committer = self._config.username()
 
116
        elif not isinstance(committer, unicode):
 
117
            self._committer = committer.decode() # throw if non-ascii
114
118
        else:
115
119
            self._committer = committer
116
120
 
170
174
            self._validate_unicode_text(value,
171
175
                                        'revision property (%s)' % (key,))
172
176
 
 
177
    def _ensure_fallback_inventories(self):
 
178
        """Ensure that appropriate inventories are available.
 
179
 
 
180
        This only applies to repositories that are stacked, and is about
 
181
        enusring the stacking invariants. Namely, that for any revision that is
 
182
        present, we either have all of the file content, or we have the parent
 
183
        inventory and the delta file content.
 
184
        """
 
185
        if not self.repository._fallback_repositories:
 
186
            return
 
187
        if not self.repository._format.supports_chks:
 
188
            raise errors.BzrError("Cannot commit directly to a stacked branch"
 
189
                " in pre-2a formats. See "
 
190
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
 
191
        # This is a stacked repo, we need to make sure we have the parent
 
192
        # inventories for the parents.
 
193
        parent_keys = [(p,) for p in self.parents]
 
194
        parent_map = self.repository.inventories._index.get_parent_map(parent_keys)
 
195
        missing_parent_keys = set([pk for pk in parent_keys
 
196
                                       if pk not in parent_map])
 
197
        fallback_repos = list(reversed(self.repository._fallback_repositories))
 
198
        missing_keys = [('inventories', pk[0])
 
199
                        for pk in missing_parent_keys]
 
200
        resume_tokens = []
 
201
        while missing_keys and fallback_repos:
 
202
            fallback_repo = fallback_repos.pop()
 
203
            source = fallback_repo._get_source(self.repository._format)
 
204
            sink = self.repository._get_sink()
 
205
            stream = source.get_stream_for_missing_keys(missing_keys)
 
206
            missing_keys = sink.insert_stream_without_locking(stream,
 
207
                self.repository._format)
 
208
        if missing_keys:
 
209
            raise errors.BzrError('Unable to fill in parent inventories for a'
 
210
                                  ' stacked branch')
 
211
 
173
212
    def commit(self, message):
174
213
        """Make the actual commit.
175
214
 
187
226
        rev.parent_ids = self.parents
188
227
        self.repository.add_revision(self._new_revision_id, rev,
189
228
            self.new_inventory, self._config)
 
229
        self._ensure_fallback_inventories()
190
230
        self.repository.commit_write_group()
191
231
        return self._new_revision_id
192
232
 
241
281
 
242
282
    def _gen_revision_id(self):
243
283
        """Return new revision-id."""
244
 
        return generate_ids.gen_revision_id(self._config.username(),
245
 
                                            self._timestamp)
 
284
        return generate_ids.gen_revision_id(self._committer, self._timestamp)
246
285
 
247
286
    def _generate_revision_if_needed(self):
248
287
        """Create a revision id if None was supplied.
288
327
 
289
328
        :param tree: The tree which is being committed.
290
329
        """
291
 
        # NB: if there are no parents then this method is not called, so no
292
 
        # need to guard on parents having length.
 
330
        if len(self.parents) == 0:
 
331
            raise errors.RootMissing()
293
332
        entry = entry_factory['directory'](tree.path2id(''), '',
294
333
            None)
295
334
        entry.revision = self._new_revision_id
433
472
            else:
434
473
                # we don't need to commit this, because the caller already
435
474
                # determined that an existing revision of this file is
436
 
                # appropriate. If its not being considered for committing then
 
475
                # appropriate. If it's not being considered for committing then
437
476
                # it and all its parents to the root must be unaltered so
438
477
                # no-change against the basis.
439
478
                if ie.revision == self._new_revision_id:
755
794
                    # after iter_changes examines and decides it has changed,
756
795
                    # we will unconditionally record a new version even if some
757
796
                    # other process reverts it while commit is running (with
758
 
                    # the revert happening after iter_changes did it's
 
797
                    # the revert happening after iter_changes did its
759
798
                    # examination).
760
799
                    if change[7][1]:
761
800
                        entry.executable = True
891
930
# Repositories
892
931
 
893
932
 
894
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
933
class Repository(_RelockDebugMixin, controldir.ControlComponent):
895
934
    """Repository holding history for one or more branches.
896
935
 
897
936
    The repository holds and retrieves historical information including
944
983
        pointing to .bzr/repository.
945
984
    """
946
985
 
947
 
    # What class to use for a CommitBuilder. Often its simpler to change this
 
986
    # What class to use for a CommitBuilder. Often it's simpler to change this
948
987
    # in a Repository class subclass rather than to override
949
988
    # get_commit_builder.
950
989
    _commit_builder_class = CommitBuilder
951
 
    # The search regex used by xml based repositories to determine what things
952
 
    # where changed in a single commit.
953
 
    _file_ids_altered_regex = lazy_regex.lazy_compile(
954
 
        r'file_id="(?P<file_id>[^"]+)"'
955
 
        r'.* revision="(?P<revision_id>[^"]+)"'
956
 
        )
957
990
 
958
991
    def abort_write_group(self, suppress_errors=False):
959
992
        """Commit the contents accrued within the current write group.
1045
1078
                " id and insertion revid (%r, %r)"
1046
1079
                % (inv.revision_id, revision_id))
1047
1080
        if inv.root is None:
1048
 
            raise AssertionError()
 
1081
            raise errors.RootMissing()
1049
1082
        return self._add_inventory_checked(revision_id, inv, parents)
1050
1083
 
1051
1084
    def _add_inventory_checked(self, revision_id, inv, parents):
1556
1589
        return ret
1557
1590
 
1558
1591
    @needs_read_lock
1559
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1592
    def search_missing_revision_ids(self, other,
 
1593
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1594
            find_ghosts=True, revision_ids=None, if_present_ids=None):
1560
1595
        """Return the revision ids that other has that this does not.
1561
1596
 
1562
1597
        These are returned in topological order.
1563
1598
 
1564
1599
        revision_id: only return revision ids included by revision_id.
1565
1600
        """
 
1601
        if symbol_versioning.deprecated_passed(revision_id):
 
1602
            symbol_versioning.warn(
 
1603
                'search_missing_revision_ids(revision_id=...) was '
 
1604
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1605
                DeprecationWarning, stacklevel=3)
 
1606
            if revision_ids is not None:
 
1607
                raise AssertionError(
 
1608
                    'revision_ids is mutually exclusive with revision_id')
 
1609
            if revision_id is not None:
 
1610
                revision_ids = [revision_id]
1566
1611
        return InterRepository.get(other, self).search_missing_revision_ids(
1567
 
            revision_id, find_ghosts)
 
1612
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1613
            if_present_ids=if_present_ids)
1568
1614
 
1569
1615
    @staticmethod
1570
1616
    def open(base):
1692
1738
    def _resume_write_group(self, tokens):
1693
1739
        raise errors.UnsuspendableWriteGroup(self)
1694
1740
 
1695
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1741
    def fetch(self, source, revision_id=None, find_ghosts=False,
1696
1742
            fetch_spec=None):
1697
1743
        """Fetch the content required to construct revision_id from source.
1698
1744
 
1722
1768
                "May not fetch while in a write group.")
1723
1769
        # fast path same-url fetch operations
1724
1770
        # TODO: lift out to somewhere common with RemoteRepository
1725
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401646>
 
1771
        # <https://bugs.launchpad.net/bzr/+bug/401646>
1726
1772
        if (self.has_same_location(source)
1727
1773
            and fetch_spec is None
1728
1774
            and self._has_same_fallbacks(source)):
1732
1778
                not _mod_revision.is_null(revision_id)):
1733
1779
                self.get_revision(revision_id)
1734
1780
            return 0, []
1735
 
        # if there is no specific appropriate InterRepository, this will get
1736
 
        # the InterRepository base class, which raises an
1737
 
        # IncompatibleRepositories when asked to fetch.
1738
1781
        inter = InterRepository.get(source, self)
1739
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1782
        return inter.fetch(revision_id=revision_id,
1740
1783
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1741
1784
 
1742
1785
    def create_bundle(self, target, base, fileobj, format=None):
1756
1799
        :param revprops: Optional dictionary of revision properties.
1757
1800
        :param revision_id: Optional revision id.
1758
1801
        """
1759
 
        if self._fallback_repositories:
1760
 
            raise errors.BzrError("Cannot commit from a lightweight checkout "
1761
 
                "to a stacked branch. See "
 
1802
        if self._fallback_repositories and not self._format.supports_chks:
 
1803
            raise errors.BzrError("Cannot commit directly to a stacked branch"
 
1804
                " in pre-2a formats. See "
1762
1805
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
1763
1806
        result = self._commit_builder_class(self, parents, config,
1764
1807
            timestamp, timezone, committer, revprops, revision_id)
2013
2056
        w = self.inventories
2014
2057
        pb = ui.ui_factory.nested_progress_bar()
2015
2058
        try:
2016
 
            return self._find_text_key_references_from_xml_inventory_lines(
 
2059
            return self._serializer._find_text_key_references(
2017
2060
                w.iter_lines_added_or_present_in_keys(revision_keys, pb=pb))
2018
2061
        finally:
2019
2062
            pb.finished()
2020
2063
 
2021
 
    def _find_text_key_references_from_xml_inventory_lines(self,
2022
 
        line_iterator):
2023
 
        """Core routine for extracting references to texts from inventories.
2024
 
 
2025
 
        This performs the translation of xml lines to revision ids.
2026
 
 
2027
 
        :param line_iterator: An iterator of lines, origin_version_id
2028
 
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
2029
 
            to whether they were referred to by the inventory of the
2030
 
            revision_id that they contain. Note that if that revision_id was
2031
 
            not part of the line_iterator's output then False will be given -
2032
 
            even though it may actually refer to that key.
2033
 
        """
2034
 
        if not self._serializer.support_altered_by_hack:
2035
 
            raise AssertionError(
2036
 
                "_find_text_key_references_from_xml_inventory_lines only "
2037
 
                "supported for branches which store inventory as unnested xml"
2038
 
                ", not on %r" % self)
2039
 
        result = {}
2040
 
 
2041
 
        # this code needs to read every new line in every inventory for the
2042
 
        # inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
2043
 
        # not present in one of those inventories is unnecessary but not
2044
 
        # harmful because we are filtering by the revision id marker in the
2045
 
        # inventory lines : we only select file ids altered in one of those
2046
 
        # revisions. We don't need to see all lines in the inventory because
2047
 
        # only those added in an inventory in rev X can contain a revision=X
2048
 
        # line.
2049
 
        unescape_revid_cache = {}
2050
 
        unescape_fileid_cache = {}
2051
 
 
2052
 
        # jam 20061218 In a big fetch, this handles hundreds of thousands
2053
 
        # of lines, so it has had a lot of inlining and optimizing done.
2054
 
        # Sorry that it is a little bit messy.
2055
 
        # Move several functions to be local variables, since this is a long
2056
 
        # running loop.
2057
 
        search = self._file_ids_altered_regex.search
2058
 
        unescape = _unescape_xml
2059
 
        setdefault = result.setdefault
2060
 
        for line, line_key in line_iterator:
2061
 
            match = search(line)
2062
 
            if match is None:
2063
 
                continue
2064
 
            # One call to match.group() returning multiple items is quite a
2065
 
            # bit faster than 2 calls to match.group() each returning 1
2066
 
            file_id, revision_id = match.group('file_id', 'revision_id')
2067
 
 
2068
 
            # Inlining the cache lookups helps a lot when you make 170,000
2069
 
            # lines and 350k ids, versus 8.4 unique ids.
2070
 
            # Using a cache helps in 2 ways:
2071
 
            #   1) Avoids unnecessary decoding calls
2072
 
            #   2) Re-uses cached strings, which helps in future set and
2073
 
            #      equality checks.
2074
 
            # (2) is enough that removing encoding entirely along with
2075
 
            # the cache (so we are using plain strings) results in no
2076
 
            # performance improvement.
2077
 
            try:
2078
 
                revision_id = unescape_revid_cache[revision_id]
2079
 
            except KeyError:
2080
 
                unescaped = unescape(revision_id)
2081
 
                unescape_revid_cache[revision_id] = unescaped
2082
 
                revision_id = unescaped
2083
 
 
2084
 
            # Note that unconditionally unescaping means that we deserialise
2085
 
            # every fileid, which for general 'pull' is not great, but we don't
2086
 
            # really want to have some many fulltexts that this matters anyway.
2087
 
            # RBC 20071114.
2088
 
            try:
2089
 
                file_id = unescape_fileid_cache[file_id]
2090
 
            except KeyError:
2091
 
                unescaped = unescape(file_id)
2092
 
                unescape_fileid_cache[file_id] = unescaped
2093
 
                file_id = unescaped
2094
 
 
2095
 
            key = (file_id, revision_id)
2096
 
            setdefault(key, False)
2097
 
            if revision_id == line_key[-1]:
2098
 
                result[key] = True
2099
 
        return result
2100
 
 
2101
2064
    def _inventory_xml_lines_for_keys(self, keys):
2102
2065
        """Get a line iterator of the sort needed for findind references.
2103
2066
 
2133
2096
        revision_ids. Each altered file-ids has the exact revision_ids that
2134
2097
        altered it listed explicitly.
2135
2098
        """
2136
 
        seen = set(self._find_text_key_references_from_xml_inventory_lines(
 
2099
        seen = set(self._serializer._find_text_key_references(
2137
2100
                line_iterator).iterkeys())
2138
2101
        parent_keys = self._find_parent_keys_of_revisions(revision_keys)
2139
 
        parent_seen = set(self._find_text_key_references_from_xml_inventory_lines(
 
2102
        parent_seen = set(self._serializer._find_text_key_references(
2140
2103
            self._inventory_xml_lines_for_keys(parent_keys)))
2141
2104
        new_keys = seen - parent_seen
2142
2105
        result = {}
2510
2473
            ancestors will be traversed.
2511
2474
        """
2512
2475
        graph = self.get_graph()
2513
 
        next_id = revision_id
2514
 
        while True:
2515
 
            if next_id in (None, _mod_revision.NULL_REVISION):
2516
 
                return
2517
 
            try:
2518
 
                parents = graph.get_parent_map([next_id])[next_id]
2519
 
            except KeyError:
2520
 
                raise errors.RevisionNotPresent(next_id, self)
2521
 
            yield next_id
2522
 
            if len(parents) == 0:
2523
 
                return
2524
 
            else:
2525
 
                next_id = parents[0]
 
2476
        stop_revisions = (None, _mod_revision.NULL_REVISION)
 
2477
        return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
2526
2478
 
2527
2479
    def is_shared(self):
2528
2480
        """Return True if this repository is flagged as a shared repository."""
2629
2581
        types it should be a no-op that just returns.
2630
2582
 
2631
2583
        This stub method does not require a lock, but subclasses should use
2632
 
        @needs_write_lock as this is a long running call its reasonable to
 
2584
        @needs_write_lock as this is a long running call it's reasonable to
2633
2585
        implicitly lock for the user.
2634
2586
 
2635
2587
        :param hint: If not supplied, the whole repository is packed.
2781
2733
        return result
2782
2734
 
2783
2735
    def _warn_if_deprecated(self, branch=None):
 
2736
        if not self._format.is_deprecated():
 
2737
            return
2784
2738
        global _deprecation_warning_done
2785
2739
        if _deprecation_warning_done:
2786
2740
            return
2828
2782
        raise NotImplementedError(self.revision_graph_can_have_wrong_parents)
2829
2783
 
2830
2784
 
2831
 
# remove these delegates a while after bzr 0.15
2832
 
def __make_delegated(name, from_module):
2833
 
    def _deprecated_repository_forwarder():
2834
 
        symbol_versioning.warn('%s moved to %s in bzr 0.15'
2835
 
            % (name, from_module),
2836
 
            DeprecationWarning,
2837
 
            stacklevel=2)
2838
 
        m = __import__(from_module, globals(), locals(), [name])
2839
 
        try:
2840
 
            return getattr(m, name)
2841
 
        except AttributeError:
2842
 
            raise AttributeError('module %s has no name %s'
2843
 
                    % (m, name))
2844
 
    globals()[name] = _deprecated_repository_forwarder
2845
 
 
2846
 
for _name in [
2847
 
        'AllInOneRepository',
2848
 
        'WeaveMetaDirRepository',
2849
 
        'PreSplitOutRepositoryFormat',
2850
 
        'RepositoryFormat4',
2851
 
        'RepositoryFormat5',
2852
 
        'RepositoryFormat6',
2853
 
        'RepositoryFormat7',
2854
 
        ]:
2855
 
    __make_delegated(_name, 'bzrlib.repofmt.weaverepo')
2856
 
 
2857
 
for _name in [
2858
 
        'KnitRepository',
2859
 
        'RepositoryFormatKnit',
2860
 
        'RepositoryFormatKnit1',
2861
 
        ]:
2862
 
    __make_delegated(_name, 'bzrlib.repofmt.knitrepo')
2863
 
 
2864
 
 
2865
2785
def install_revision(repository, rev, revision_tree):
2866
2786
    """Install all revision data into a repository."""
2867
2787
    install_revisions(repository, [(rev, revision_tree, None)])
2999
2919
            control_files)
3000
2920
 
3001
2921
 
 
2922
class RepositoryFormatRegistry(controldir.ControlComponentFormatRegistry):
 
2923
    """Repository format registry."""
 
2924
 
 
2925
    def get_default(self):
 
2926
        """Return the current default format."""
 
2927
        from bzrlib import bzrdir
 
2928
        return bzrdir.format_registry.make_bzrdir('default').repository_format
 
2929
 
 
2930
 
3002
2931
network_format_registry = registry.FormatRegistry()
3003
2932
"""Registry of formats indexed by their network name.
3004
2933
 
3008
2937
"""
3009
2938
 
3010
2939
 
3011
 
format_registry = registry.FormatRegistry(network_format_registry)
 
2940
format_registry = RepositoryFormatRegistry(network_format_registry)
3012
2941
"""Registry of formats, indexed by their BzrDirMetaFormat format string.
3013
2942
 
3014
2943
This can contain either format instances themselves, or classes/factories that
3019
2948
#####################################################################
3020
2949
# Repository Formats
3021
2950
 
3022
 
class RepositoryFormat(object):
 
2951
class RepositoryFormat(controldir.ControlComponentFormat):
3023
2952
    """A repository format.
3024
2953
 
3025
2954
    Formats provide four things:
3086
3015
    supports_tree_reference = None
3087
3016
    # Is the format experimental ?
3088
3017
    experimental = False
 
3018
    # Does this repository format escape funky characters, or does it create files with
 
3019
    # similar names as the versioned files in its contents on disk ?
 
3020
    supports_funky_characters = None
 
3021
    # Does this repository format support leaving locks?
 
3022
    supports_leaving_lock = None
 
3023
    # Does this format support the full VersionedFiles interface?
 
3024
    supports_full_versioned_files = None
3089
3025
 
3090
3026
    def __repr__(self):
3091
3027
        return "%s()" % self.__class__.__name__
3116
3052
                                            kind='repository')
3117
3053
 
3118
3054
    @classmethod
 
3055
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
3119
3056
    def register_format(klass, format):
3120
 
        format_registry.register(format.get_format_string(), format)
 
3057
        format_registry.register(format)
3121
3058
 
3122
3059
    @classmethod
 
3060
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
3123
3061
    def unregister_format(klass, format):
3124
 
        format_registry.remove(format.get_format_string())
 
3062
        format_registry.remove(format)
3125
3063
 
3126
3064
    @classmethod
 
3065
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
3127
3066
    def get_default_format(klass):
3128
3067
        """Return the current default format."""
3129
 
        from bzrlib import bzrdir
3130
 
        return bzrdir.format_registry.make_bzrdir('default').repository_format
 
3068
        return format_registry.get_default()
3131
3069
 
3132
3070
    def get_format_string(self):
3133
3071
        """Return the ASCII format string that identifies this format.
3184
3122
        """
3185
3123
        return True
3186
3124
 
 
3125
    def is_deprecated(self):
 
3126
        """Is this format deprecated?
 
3127
 
 
3128
        Deprecated formats may trigger a user-visible warning recommending
 
3129
        the user to upgrade. They are still fully supported.
 
3130
        """
 
3131
        return False
 
3132
 
3187
3133
    def network_name(self):
3188
3134
        """A simple byte string uniquely identifying this format for RPC calls.
3189
3135
 
3228
3174
    rich_root_data = False
3229
3175
    supports_tree_reference = False
3230
3176
    supports_external_lookups = False
 
3177
    supports_leaving_lock = True
3231
3178
 
3232
3179
    @property
3233
3180
    def _matchingbzrdir(self):
3271
3218
        return self.get_format_string()
3272
3219
 
3273
3220
 
3274
 
# Pre-0.8 formats that don't have a disk format string (because they are
3275
 
# versioned by the matching control directory). We use the control directories
3276
 
# disk format string as a key for the network_name because they meet the
3277
 
# constraints (simple string, unique, immutable).
3278
 
network_format_registry.register_lazy(
3279
 
    "Bazaar-NG branch, format 5\n",
3280
 
    'bzrlib.repofmt.weaverepo',
3281
 
    'RepositoryFormat5',
3282
 
)
3283
 
network_format_registry.register_lazy(
3284
 
    "Bazaar-NG branch, format 6\n",
3285
 
    'bzrlib.repofmt.weaverepo',
3286
 
    'RepositoryFormat6',
3287
 
)
3288
 
 
3289
3221
# formats which have no format string are not discoverable or independently
3290
3222
# creatable on disk, so are not registered in format_registry.  They're
3291
 
# all in bzrlib.repofmt.weaverepo now.  When an instance of one of these is
 
3223
# all in bzrlib.repofmt.knitreponow.  When an instance of one of these is
3292
3224
# needed, it's constructed directly by the BzrDir.  Non-native formats where
3293
3225
# the repository is not separately opened are similar.
3294
3226
 
3295
3227
format_registry.register_lazy(
3296
 
    'Bazaar-NG Repository format 7',
3297
 
    'bzrlib.repofmt.weaverepo',
3298
 
    'RepositoryFormat7'
3299
 
    )
3300
 
 
3301
 
format_registry.register_lazy(
3302
3228
    'Bazaar-NG Knit Repository Format 1',
3303
3229
    'bzrlib.repofmt.knitrepo',
3304
3230
    'RepositoryFormatKnit1',
3359
3285
    'bzrlib.repofmt.pack_repo',
3360
3286
    'RepositoryFormatKnitPack6RichRoot',
3361
3287
    )
 
3288
format_registry.register_lazy(
 
3289
    'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
 
3290
    'bzrlib.repofmt.groupcompress_repo',
 
3291
    'RepositoryFormat2a',
 
3292
    )
3362
3293
 
3363
3294
# Development formats.
3364
 
# Obsolete but kept pending a CHK based subtree format.
 
3295
# Check their docstrings to see if/when they are obsolete.
3365
3296
format_registry.register_lazy(
3366
3297
    ("Bazaar development format 2 with subtree support "
3367
3298
        "(needs bzr.dev from before 1.8)\n"),
3368
3299
    'bzrlib.repofmt.pack_repo',
3369
3300
    'RepositoryFormatPackDevelopment2Subtree',
3370
3301
    )
3371
 
 
3372
 
# 1.14->1.16 go below here
3373
 
format_registry.register_lazy(
3374
 
    'Bazaar development format - group compression and chk inventory'
3375
 
        ' (needs bzr.dev from 1.14)\n',
3376
 
    'bzrlib.repofmt.groupcompress_repo',
3377
 
    'RepositoryFormatCHK1',
3378
 
    )
3379
 
 
3380
 
format_registry.register_lazy(
3381
 
    'Bazaar development format - chk repository with bencode revision '
3382
 
        'serialization (needs bzr.dev from 1.16)\n',
3383
 
    'bzrlib.repofmt.groupcompress_repo',
3384
 
    'RepositoryFormatCHK2',
3385
 
    )
3386
 
format_registry.register_lazy(
3387
 
    'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
3388
 
    'bzrlib.repofmt.groupcompress_repo',
3389
 
    'RepositoryFormat2a',
 
3302
format_registry.register_lazy(
 
3303
    'Bazaar development format 8\n',
 
3304
    'bzrlib.repofmt.groupcompress_repo',
 
3305
    'RepositoryFormat2aSubtree',
3390
3306
    )
3391
3307
 
3392
3308
 
3423
3339
        self.target.fetch(self.source, revision_id=revision_id)
3424
3340
 
3425
3341
    @needs_write_lock
3426
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
 
3342
    def fetch(self, revision_id=None, find_ghosts=False,
3427
3343
            fetch_spec=None):
3428
3344
        """Fetch the content required to construct revision_id.
3429
3345
 
3431
3347
 
3432
3348
        :param revision_id: if None all content is copied, if NULL_REVISION no
3433
3349
                            content is copied.
3434
 
        :param pb: ignored.
3435
3350
        :return: None.
3436
3351
        """
3437
3352
        ui.ui_factory.warn_experimental_format_fetch(self)
3447
3362
                               fetch_spec=fetch_spec,
3448
3363
                               find_ghosts=find_ghosts)
3449
3364
 
3450
 
    def _walk_to_common_revisions(self, revision_ids):
 
3365
    def _walk_to_common_revisions(self, revision_ids, if_present_ids=None):
3451
3366
        """Walk out from revision_ids in source to revisions target has.
3452
3367
 
3453
3368
        :param revision_ids: The start point for the search.
3455
3370
        """
3456
3371
        target_graph = self.target.get_graph()
3457
3372
        revision_ids = frozenset(revision_ids)
 
3373
        if if_present_ids:
 
3374
            all_wanted_revs = revision_ids.union(if_present_ids)
 
3375
        else:
 
3376
            all_wanted_revs = revision_ids
3458
3377
        missing_revs = set()
3459
3378
        source_graph = self.source.get_graph()
3460
3379
        # ensure we don't pay silly lookup costs.
3461
 
        searcher = source_graph._make_breadth_first_searcher(revision_ids)
 
3380
        searcher = source_graph._make_breadth_first_searcher(all_wanted_revs)
3462
3381
        null_set = frozenset([_mod_revision.NULL_REVISION])
3463
3382
        searcher_exhausted = False
3464
3383
        while True:
3500
3419
        return searcher.get_result()
3501
3420
 
3502
3421
    @needs_read_lock
3503
 
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
3422
    def search_missing_revision_ids(self,
 
3423
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
3424
            find_ghosts=True, revision_ids=None, if_present_ids=None):
3504
3425
        """Return the revision ids that source has that target does not.
3505
3426
 
3506
3427
        :param revision_id: only return revision ids included by this
3507
 
                            revision_id.
 
3428
            revision_id.
 
3429
        :param revision_ids: return revision ids included by these
 
3430
            revision_ids.  NoSuchRevision will be raised if any of these
 
3431
            revisions are not present.
 
3432
        :param if_present_ids: like revision_ids, but will not cause
 
3433
            NoSuchRevision if any of these are absent, instead they will simply
 
3434
            not be in the result.  This is useful for e.g. finding revisions
 
3435
            to fetch for tags, which may reference absent revisions.
3508
3436
        :param find_ghosts: If True find missing revisions in deep history
3509
3437
            rather than just finding the surface difference.
3510
3438
        :return: A bzrlib.graph.SearchResult.
3511
3439
        """
 
3440
        if symbol_versioning.deprecated_passed(revision_id):
 
3441
            symbol_versioning.warn(
 
3442
                'search_missing_revision_ids(revision_id=...) was '
 
3443
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
3444
                DeprecationWarning, stacklevel=2)
 
3445
            if revision_ids is not None:
 
3446
                raise AssertionError(
 
3447
                    'revision_ids is mutually exclusive with revision_id')
 
3448
            if revision_id is not None:
 
3449
                revision_ids = [revision_id]
 
3450
        del revision_id
3512
3451
        # stop searching at found target revisions.
3513
 
        if not find_ghosts and revision_id is not None:
3514
 
            return self._walk_to_common_revisions([revision_id])
 
3452
        if not find_ghosts and (revision_ids is not None or if_present_ids is
 
3453
                not None):
 
3454
            return self._walk_to_common_revisions(revision_ids,
 
3455
                    if_present_ids=if_present_ids)
3515
3456
        # generic, possibly worst case, slow code path.
3516
3457
        target_ids = set(self.target.all_revision_ids())
3517
 
        if revision_id is not None:
3518
 
            source_ids = self.source.get_ancestry(revision_id)
3519
 
            if source_ids[0] is not None:
3520
 
                raise AssertionError()
3521
 
            source_ids.pop(0)
3522
 
        else:
3523
 
            source_ids = self.source.all_revision_ids()
 
3458
        source_ids = self._present_source_revisions_for(
 
3459
            revision_ids, if_present_ids)
3524
3460
        result_set = set(source_ids).difference(target_ids)
3525
3461
        return self.source.revision_ids_to_search_result(result_set)
3526
3462
 
 
3463
    def _present_source_revisions_for(self, revision_ids, if_present_ids=None):
 
3464
        """Returns set of all revisions in ancestry of revision_ids present in
 
3465
        the source repo.
 
3466
 
 
3467
        :param revision_ids: if None, all revisions in source are returned.
 
3468
        :param if_present_ids: like revision_ids, but if any/all of these are
 
3469
            absent no error is raised.
 
3470
        """
 
3471
        if revision_ids is not None or if_present_ids is not None:
 
3472
            # First, ensure all specified revisions exist.  Callers expect
 
3473
            # NoSuchRevision when they pass absent revision_ids here.
 
3474
            if revision_ids is None:
 
3475
                revision_ids = set()
 
3476
            if if_present_ids is None:
 
3477
                if_present_ids = set()
 
3478
            revision_ids = set(revision_ids)
 
3479
            if_present_ids = set(if_present_ids)
 
3480
            all_wanted_ids = revision_ids.union(if_present_ids)
 
3481
            graph = self.source.get_graph()
 
3482
            present_revs = set(graph.get_parent_map(all_wanted_ids))
 
3483
            missing = revision_ids.difference(present_revs)
 
3484
            if missing:
 
3485
                raise errors.NoSuchRevision(self.source, missing.pop())
 
3486
            found_ids = all_wanted_ids.intersection(present_revs)
 
3487
            source_ids = [rev_id for (rev_id, parents) in
 
3488
                          graph.iter_ancestry(found_ids)
 
3489
                          if rev_id != _mod_revision.NULL_REVISION
 
3490
                          and parents is not None]
 
3491
        else:
 
3492
            source_ids = self.source.all_revision_ids()
 
3493
        return set(source_ids)
 
3494
 
3527
3495
    @staticmethod
3528
3496
    def _same_model(source, target):
3529
3497
        """True if source and target have the same data representation.
3570
3538
        return InterRepository._same_model(source, target)
3571
3539
 
3572
3540
 
3573
 
class InterWeaveRepo(InterSameDataRepository):
3574
 
    """Optimised code paths between Weave based repositories.
3575
 
 
3576
 
    This should be in bzrlib/repofmt/weaverepo.py but we have not yet
3577
 
    implemented lazy inter-object optimisation.
3578
 
    """
3579
 
 
3580
 
    @classmethod
3581
 
    def _get_repo_format_to_test(self):
3582
 
        from bzrlib.repofmt import weaverepo
3583
 
        return weaverepo.RepositoryFormat7()
3584
 
 
3585
 
    @staticmethod
3586
 
    def is_compatible(source, target):
3587
 
        """Be compatible with known Weave formats.
3588
 
 
3589
 
        We don't test for the stores being of specific types because that
3590
 
        could lead to confusing results, and there is no need to be
3591
 
        overly general.
3592
 
        """
3593
 
        from bzrlib.repofmt.weaverepo import (
3594
 
                RepositoryFormat5,
3595
 
                RepositoryFormat6,
3596
 
                RepositoryFormat7,
3597
 
                )
3598
 
        try:
3599
 
            return (isinstance(source._format, (RepositoryFormat5,
3600
 
                                                RepositoryFormat6,
3601
 
                                                RepositoryFormat7)) and
3602
 
                    isinstance(target._format, (RepositoryFormat5,
3603
 
                                                RepositoryFormat6,
3604
 
                                                RepositoryFormat7)))
3605
 
        except AttributeError:
3606
 
            return False
3607
 
 
3608
 
    @needs_write_lock
3609
 
    def copy_content(self, revision_id=None):
3610
 
        """See InterRepository.copy_content()."""
3611
 
        # weave specific optimised path:
3612
 
        try:
3613
 
            self.target.set_make_working_trees(self.source.make_working_trees())
3614
 
        except (errors.RepositoryUpgradeRequired, NotImplemented):
3615
 
            pass
3616
 
        # FIXME do not peek!
3617
 
        if self.source._transport.listable():
3618
 
            pb = ui.ui_factory.nested_progress_bar()
3619
 
            try:
3620
 
                self.target.texts.insert_record_stream(
3621
 
                    self.source.texts.get_record_stream(
3622
 
                        self.source.texts.keys(), 'topological', False))
3623
 
                pb.update('Copying inventory', 0, 1)
3624
 
                self.target.inventories.insert_record_stream(
3625
 
                    self.source.inventories.get_record_stream(
3626
 
                        self.source.inventories.keys(), 'topological', False))
3627
 
                self.target.signatures.insert_record_stream(
3628
 
                    self.source.signatures.get_record_stream(
3629
 
                        self.source.signatures.keys(),
3630
 
                        'unordered', True))
3631
 
                self.target.revisions.insert_record_stream(
3632
 
                    self.source.revisions.get_record_stream(
3633
 
                        self.source.revisions.keys(),
3634
 
                        'topological', True))
3635
 
            finally:
3636
 
                pb.finished()
3637
 
        else:
3638
 
            self.target.fetch(self.source, revision_id=revision_id)
3639
 
 
3640
 
    @needs_read_lock
3641
 
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
3642
 
        """See InterRepository.missing_revision_ids()."""
3643
 
        # we want all revisions to satisfy revision_id in source.
3644
 
        # but we don't want to stat every file here and there.
3645
 
        # we want then, all revisions other needs to satisfy revision_id
3646
 
        # checked, but not those that we have locally.
3647
 
        # so the first thing is to get a subset of the revisions to
3648
 
        # satisfy revision_id in source, and then eliminate those that
3649
 
        # we do already have.
3650
 
        # this is slow on high latency connection to self, but as this
3651
 
        # disk format scales terribly for push anyway due to rewriting
3652
 
        # inventory.weave, this is considered acceptable.
3653
 
        # - RBC 20060209
3654
 
        if revision_id is not None:
3655
 
            source_ids = self.source.get_ancestry(revision_id)
3656
 
            if source_ids[0] is not None:
3657
 
                raise AssertionError()
3658
 
            source_ids.pop(0)
3659
 
        else:
3660
 
            source_ids = self.source._all_possible_ids()
3661
 
        source_ids_set = set(source_ids)
3662
 
        # source_ids is the worst possible case we may need to pull.
3663
 
        # now we want to filter source_ids against what we actually
3664
 
        # have in target, but don't try to check for existence where we know
3665
 
        # we do not have a revision as that would be pointless.
3666
 
        target_ids = set(self.target._all_possible_ids())
3667
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
3668
 
        actually_present_revisions = set(
3669
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
3670
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
3671
 
        if revision_id is not None:
3672
 
            # we used get_ancestry to determine source_ids then we are assured all
3673
 
            # revisions referenced are present as they are installed in topological order.
3674
 
            # and the tip revision was validated by get_ancestry.
3675
 
            result_set = required_revisions
3676
 
        else:
3677
 
            # if we just grabbed the possibly available ids, then
3678
 
            # we only have an estimate of whats available and need to validate
3679
 
            # that against the revision records.
3680
 
            result_set = set(
3681
 
                self.source._eliminate_revisions_not_present(required_revisions))
3682
 
        return self.source.revision_ids_to_search_result(result_set)
3683
 
 
3684
 
 
3685
 
class InterKnitRepo(InterSameDataRepository):
3686
 
    """Optimised code paths between Knit based repositories."""
3687
 
 
3688
 
    @classmethod
3689
 
    def _get_repo_format_to_test(self):
3690
 
        from bzrlib.repofmt import knitrepo
3691
 
        return knitrepo.RepositoryFormatKnit1()
3692
 
 
3693
 
    @staticmethod
3694
 
    def is_compatible(source, target):
3695
 
        """Be compatible with known Knit formats.
3696
 
 
3697
 
        We don't test for the stores being of specific types because that
3698
 
        could lead to confusing results, and there is no need to be
3699
 
        overly general.
3700
 
        """
3701
 
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit
3702
 
        try:
3703
 
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
3704
 
                isinstance(target._format, RepositoryFormatKnit))
3705
 
        except AttributeError:
3706
 
            return False
3707
 
        return are_knits and InterRepository._same_model(source, target)
3708
 
 
3709
 
    @needs_read_lock
3710
 
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
3711
 
        """See InterRepository.missing_revision_ids()."""
3712
 
        if revision_id is not None:
3713
 
            source_ids = self.source.get_ancestry(revision_id)
3714
 
            if source_ids[0] is not None:
3715
 
                raise AssertionError()
3716
 
            source_ids.pop(0)
3717
 
        else:
3718
 
            source_ids = self.source.all_revision_ids()
3719
 
        source_ids_set = set(source_ids)
3720
 
        # source_ids is the worst possible case we may need to pull.
3721
 
        # now we want to filter source_ids against what we actually
3722
 
        # have in target, but don't try to check for existence where we know
3723
 
        # we do not have a revision as that would be pointless.
3724
 
        target_ids = set(self.target.all_revision_ids())
3725
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
3726
 
        actually_present_revisions = set(
3727
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
3728
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
3729
 
        if revision_id is not None:
3730
 
            # we used get_ancestry to determine source_ids then we are assured all
3731
 
            # revisions referenced are present as they are installed in topological order.
3732
 
            # and the tip revision was validated by get_ancestry.
3733
 
            result_set = required_revisions
3734
 
        else:
3735
 
            # if we just grabbed the possibly available ids, then
3736
 
            # we only have an estimate of whats available and need to validate
3737
 
            # that against the revision records.
3738
 
            result_set = set(
3739
 
                self.source._eliminate_revisions_not_present(required_revisions))
3740
 
        return self.source.revision_ids_to_search_result(result_set)
3741
 
 
3742
 
 
3743
3541
class InterDifferingSerializer(InterRepository):
3744
3542
 
3745
3543
    @classmethod
3847
3645
                basis_id, delta, current_revision_id, parents_parents)
3848
3646
            cache[current_revision_id] = parent_tree
3849
3647
 
3850
 
    def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
 
3648
    def _fetch_batch(self, revision_ids, basis_id, cache):
3851
3649
        """Fetch across a few revisions.
3852
3650
 
3853
3651
        :param revision_ids: The revisions to copy
3854
3652
        :param basis_id: The revision_id of a tree that must be in cache, used
3855
3653
            as a basis for delta when no other base is available
3856
3654
        :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
3655
        :return: The revision_id of the last converted tree. The RevisionTree
3860
3656
            for it will be in cache
3861
3657
        """
3929
3725
        if root_keys_to_create:
3930
3726
            root_stream = _mod_fetch._new_root_data_stream(
3931
3727
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3932
 
                self.source, graph=a_graph)
 
3728
                self.source)
3933
3729
            to_texts.insert_record_stream(root_stream)
3934
3730
        to_texts.insert_record_stream(from_texts.get_record_stream(
3935
3731
            text_keys, self.target._format._fetch_order,
3992
3788
        cache[basis_id] = basis_tree
3993
3789
        del basis_tree # We don't want to hang on to it here
3994
3790
        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
 
3791
        a_graph = None
4000
3792
 
4001
3793
        for offset in range(0, len(revision_ids), batch_size):
4002
3794
            self.target.start_write_group()
4004
3796
                pb.update('Transferring revisions', offset,
4005
3797
                          len(revision_ids))
4006
3798
                batch = revision_ids[offset:offset+batch_size]
4007
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
4008
 
                                             a_graph=a_graph)
 
3799
                basis_id = self._fetch_batch(batch, basis_id, cache)
4009
3800
            except:
4010
3801
                self.source._safe_to_return_from_cache = False
4011
3802
                self.target.abort_write_group()
4020
3811
                  len(revision_ids))
4021
3812
 
4022
3813
    @needs_write_lock
4023
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
 
3814
    def fetch(self, revision_id=None, find_ghosts=False,
4024
3815
            fetch_spec=None):
4025
3816
        """See InterRepository.fetch()."""
4026
3817
        if fetch_spec is not None:
4027
 
            raise AssertionError("Not implemented yet...")
 
3818
            revision_ids = fetch_spec.get_keys()
 
3819
        else:
 
3820
            revision_ids = None
4028
3821
        ui.ui_factory.warn_experimental_format_fetch(self)
4029
3822
        if (not self.source.supports_rich_root()
4030
3823
            and self.target.supports_rich_root()):
4037
3830
            ui.ui_factory.show_user_warning('cross_format_fetch',
4038
3831
                from_format=self.source._format,
4039
3832
                to_format=self.target._format)
4040
 
        revision_ids = self.target.search_missing_revision_ids(self.source,
4041
 
            revision_id, find_ghosts=find_ghosts).get_keys()
 
3833
        if revision_ids is None:
 
3834
            if revision_id:
 
3835
                search_revision_ids = [revision_id]
 
3836
            else:
 
3837
                search_revision_ids = None
 
3838
            revision_ids = self.target.search_missing_revision_ids(self.source,
 
3839
                revision_ids=search_revision_ids,
 
3840
                find_ghosts=find_ghosts).get_keys()
4042
3841
        if not revision_ids:
4043
3842
            return 0, 0
4044
3843
        revision_ids = tsort.topo_sort(
4048
3847
        # Walk though all revisions; get inventory deltas, copy referenced
4049
3848
        # texts that delta references, insert the delta, revision and
4050
3849
        # signature.
4051
 
        if pb is None:
4052
 
            my_pb = ui.ui_factory.nested_progress_bar()
4053
 
            pb = my_pb
4054
 
        else:
4055
 
            symbol_versioning.warn(
4056
 
                symbol_versioning.deprecated_in((1, 14, 0))
4057
 
                % "pb parameter to fetch()")
4058
 
            my_pb = None
 
3850
        pb = ui.ui_factory.nested_progress_bar()
4059
3851
        try:
4060
3852
            self._fetch_all_revisions(revision_ids, pb)
4061
3853
        finally:
4062
 
            if my_pb is not None:
4063
 
                my_pb.finished()
 
3854
            pb.finished()
4064
3855
        return len(revision_ids), 0
4065
3856
 
4066
3857
    def _get_basis(self, first_revision_id):
4077
3868
            basis_id = first_rev.parent_ids[0]
4078
3869
            # only valid as a basis if the target has it
4079
3870
            self.target.get_revision(basis_id)
4080
 
            # Try to get a basis tree - if its a ghost it will hit the
 
3871
            # Try to get a basis tree - if it's a ghost it will hit the
4081
3872
            # NoSuchRevision case.
4082
3873
            basis_tree = self.source.revision_tree(basis_id)
4083
3874
        except (IndexError, errors.NoSuchRevision):
4088
3879
 
4089
3880
InterRepository.register_optimiser(InterDifferingSerializer)
4090
3881
InterRepository.register_optimiser(InterSameDataRepository)
4091
 
InterRepository.register_optimiser(InterWeaveRepo)
4092
 
InterRepository.register_optimiser(InterKnitRepo)
4093
3882
 
4094
3883
 
4095
3884
class CopyConverter(object):
4140
3929
        pb.finished()
4141
3930
 
4142
3931
 
4143
 
_unescape_map = {
4144
 
    'apos':"'",
4145
 
    'quot':'"',
4146
 
    'amp':'&',
4147
 
    'lt':'<',
4148
 
    'gt':'>'
4149
 
}
4150
 
 
4151
 
 
4152
 
def _unescaper(match, _map=_unescape_map):
4153
 
    code = match.group(1)
4154
 
    try:
4155
 
        return _map[code]
4156
 
    except KeyError:
4157
 
        if not code.startswith('#'):
4158
 
            raise
4159
 
        return unichr(int(code[1:])).encode('utf8')
4160
 
 
4161
 
 
4162
 
_unescape_re = None
4163
 
 
4164
 
 
4165
 
def _unescape_xml(data):
4166
 
    """Unescape predefined XML entities in a string of data."""
4167
 
    global _unescape_re
4168
 
    if _unescape_re is None:
4169
 
        _unescape_re = re.compile('\&([^;]*);')
4170
 
    return _unescape_re.sub(_unescaper, data)
4171
 
 
4172
 
 
4173
3932
class _VersionedFileChecker(object):
4174
3933
 
4175
3934
    def __init__(self, repository, text_key_references=None, ancestors=None):
4283
4042
                is_resume = False
4284
4043
            try:
4285
4044
                # locked_insert_stream performs a commit|suspend.
4286
 
                return self._locked_insert_stream(stream, src_format, is_resume)
 
4045
                missing_keys = self.insert_stream_without_locking(stream,
 
4046
                                    src_format, is_resume)
 
4047
                if missing_keys:
 
4048
                    # suspend the write group and tell the caller what we is
 
4049
                    # missing. We know we can suspend or else we would not have
 
4050
                    # entered this code path. (All repositories that can handle
 
4051
                    # missing keys can handle suspending a write group).
 
4052
                    write_group_tokens = self.target_repo.suspend_write_group()
 
4053
                    return write_group_tokens, missing_keys
 
4054
                hint = self.target_repo.commit_write_group()
 
4055
                to_serializer = self.target_repo._format._serializer
 
4056
                src_serializer = src_format._serializer
 
4057
                if (to_serializer != src_serializer and
 
4058
                    self.target_repo._format.pack_compresses):
 
4059
                    self.target_repo.pack(hint=hint)
 
4060
                return [], set()
4287
4061
            except:
4288
4062
                self.target_repo.abort_write_group(suppress_errors=True)
4289
4063
                raise
4290
4064
        finally:
4291
4065
            self.target_repo.unlock()
4292
4066
 
4293
 
    def _locked_insert_stream(self, stream, src_format, is_resume):
 
4067
    def insert_stream_without_locking(self, stream, src_format,
 
4068
                                      is_resume=False):
 
4069
        """Insert a stream's content into the target repository.
 
4070
 
 
4071
        This assumes that you already have a locked repository and an active
 
4072
        write group.
 
4073
 
 
4074
        :param src_format: a bzr repository format.
 
4075
        :param is_resume: Passed down to get_missing_parent_inventories to
 
4076
            indicate if we should be checking for missing texts at the same
 
4077
            time.
 
4078
 
 
4079
        :return: A set of keys that are missing.
 
4080
        """
 
4081
        if not self.target_repo.is_write_locked():
 
4082
            raise errors.ObjectNotLocked(self)
 
4083
        if not self.target_repo.is_in_write_group():
 
4084
            raise errors.BzrError('you must already be in a write group')
4294
4085
        to_serializer = self.target_repo._format._serializer
4295
4086
        src_serializer = src_format._serializer
4296
4087
        new_pack = None
4336
4127
                # required if the serializers are different only in terms of
4337
4128
                # the inventory.
4338
4129
                if src_serializer == to_serializer:
4339
 
                    self.target_repo.revisions.insert_record_stream(
4340
 
                        substream)
 
4130
                    self.target_repo.revisions.insert_record_stream(substream)
4341
4131
                else:
4342
4132
                    self._extract_and_insert_revisions(substream,
4343
4133
                        src_serializer)
4376
4166
            # cannot even attempt suspending, and missing would have failed
4377
4167
            # during stream insertion.
4378
4168
            missing_keys = set()
4379
 
        else:
4380
 
            if missing_keys:
4381
 
                # suspend the write group and tell the caller what we is
4382
 
                # missing. We know we can suspend or else we would not have
4383
 
                # entered this code path. (All repositories that can handle
4384
 
                # missing keys can handle suspending a write group).
4385
 
                write_group_tokens = self.target_repo.suspend_write_group()
4386
 
                return write_group_tokens, missing_keys
4387
 
        hint = self.target_repo.commit_write_group()
4388
 
        if (to_serializer != src_serializer and
4389
 
            self.target_repo._format.pack_compresses):
4390
 
            self.target_repo.pack(hint=hint)
4391
 
        return [], set()
 
4169
        return missing_keys
4392
4170
 
4393
4171
    def _extract_and_insert_inventory_deltas(self, substream, serializer):
4394
4172
        target_rich_root = self.target_repo._format.rich_root_data
4451
4229
        """Create a StreamSource streaming from from_repository."""
4452
4230
        self.from_repository = from_repository
4453
4231
        self.to_format = to_format
 
4232
        self._record_counter = RecordCounter()
4454
4233
 
4455
4234
    def delta_on_metadata(self):
4456
4235
        """Return True if delta's are permitted on metadata streams.
4742
4521
        # No more history
4743
4522
        return
4744
4523
 
 
4524
 
 
4525