← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: John Arbash Meinel
  • Date: 2009-02-23 15:29:35 UTC
  • mfrom: (3943.7.7 bzr.code_style_cleanup)
  • mto: This revision was merged to the branch mainline in revision 4033.
  • Revision ID: john@arbash-meinel.com-20090223152935-oel9m92mwcc6nb4h
Merge the removal of all trailing whitespace, and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
199
199
 
200
200
    def _generate_revision_if_needed(self):
201
201
        """Create a revision id if None was supplied.
202
 
        
 
202
 
203
203
        If the repository can not support user-specified revision ids
204
204
        they should override this function and raise CannotSetRevisionId
205
205
        if _new_revision_id is not None.
301
301
        :param parent_invs: The inventories of the parent revisions of the
302
302
            commit.
303
303
        :param path: The path the entry is at in the tree.
304
 
        :param tree: The tree which contains this entry and should be used to 
 
304
        :param tree: The tree which contains this entry and should be used to
305
305
            obtain content.
306
306
        :param content_summary: Summary data from the tree about the paths
307
307
            content - stat, length, exec, sha/link target. This is only
514
514
 
515
515
class RootCommitBuilder(CommitBuilder):
516
516
    """This commitbuilder actually records the root id"""
517
 
    
 
517
 
518
518
    # the root entry gets versioned properly by this builder.
519
519
    _versioned_root = True
520
520
 
613
613
 
614
614
    def _abort_write_group(self):
615
615
        """Template method for per-repository write group cleanup.
616
 
        
617
 
        This is called during abort before the write group is considered to be 
 
616
 
 
617
        This is called during abort before the write group is considered to be
618
618
        finished and should cleanup any internal state accrued during the write
619
619
        group. There is no requirement that data handed to the repository be
620
620
        *not* made available - this is not a rollback - but neither should any
626
626
 
627
627
    def add_fallback_repository(self, repository):
628
628
        """Add a repository to use for looking up data not held locally.
629
 
        
 
629
 
630
630
        :param repository: A repository.
631
631
        """
632
632
        if not self._format.supports_external_lookups:
643
643
        """Check that this repository can fallback to repository safely.
644
644
 
645
645
        Raise an error if not.
646
 
        
 
646
 
647
647
        :param repository: A repository to fallback to.
648
648
        """
649
649
        return InterRepository._assert_same_model(self, repository)
650
650
 
651
651
    def add_inventory(self, revision_id, inv, parents):
652
652
        """Add the inventory inv to the repository as revision_id.
653
 
        
 
653
 
654
654
        :param parents: The revision ids of the parents that revision_id
655
655
                        is known to have and are in the repository already.
656
656
 
758
758
        self.revisions.add_lines(key, parents, osutils.split_lines(text))
759
759
 
760
760
    def all_revision_ids(self):
761
 
        """Returns a list of all the revision ids in the repository. 
 
761
        """Returns a list of all the revision ids in the repository.
762
762
 
763
763
        This is conceptually deprecated because code should generally work on
764
764
        the graph reachable from a particular revision, and ignore any other
770
770
        return self._all_revision_ids()
771
771
 
772
772
    def _all_revision_ids(self):
773
 
        """Returns a list of all the revision ids in the repository. 
 
773
        """Returns a list of all the revision ids in the repository.
774
774
 
775
 
        These are in as much topological order as the underlying store can 
 
775
        These are in as much topological order as the underlying store can
776
776
        present.
777
777
        """
778
778
        raise NotImplementedError(self._all_revision_ids)
823
823
        self._reconcile_does_inventory_gc = True
824
824
        self._reconcile_fixes_text_parents = False
825
825
        self._reconcile_backsup_inventory = True
826
 
        # not right yet - should be more semantically clear ? 
827
 
        # 
 
826
        # not right yet - should be more semantically clear ?
 
827
        #
828
828
        # TODO: make sure to construct the right store classes, etc, depending
829
829
        # on whether escaping is required.
830
830
        self._warn_if_deprecated()
881
881
        This causes caching within the repository obejct to start accumlating
882
882
        data during reads, and allows a 'write_group' to be obtained. Write
883
883
        groups must be used for actual data insertion.
884
 
        
 
884
 
885
885
        :param token: if this is already locked, then lock_write will fail
886
886
            unless the token matches the existing lock.
887
887
        :returns: a token if this instance supports tokens, otherwise None.
916
916
    def leave_lock_in_place(self):
917
917
        """Tell this repository not to release the physical lock when this
918
918
        object is unlocked.
919
 
        
 
919
 
920
920
        If lock_write doesn't return a token, then this method is not supported.
921
921
        """
922
922
        self.control_files.leave_in_place()
1028
1028
    @needs_read_lock
1029
1029
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1030
1030
        """Return the revision ids that other has that this does not.
1031
 
        
 
1031
 
1032
1032
        These are returned in topological order.
1033
1033
 
1034
1034
        revision_id: only return revision ids included by revision_id.
1040
1040
    @needs_read_lock
1041
1041
    def missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1042
1042
        """Return the revision ids that other has that this does not.
1043
 
        
 
1043
 
1044
1044
        These are returned in topological order.
1045
1045
 
1046
1046
        revision_id: only return revision ids included by revision_id.
1066
1066
 
1067
1067
    def copy_content_into(self, destination, revision_id=None):
1068
1068
        """Make a complete copy of the content in self into destination.
1069
 
        
1070
 
        This is a destructive operation! Do not use it on existing 
 
1069
 
 
1070
        This is a destructive operation! Do not use it on existing
1071
1071
        repositories.
1072
1072
        """
1073
1073
        return InterRepository.get(self, destination).copy_content(revision_id)
1087
1087
 
1088
1088
    def _commit_write_group(self):
1089
1089
        """Template method for per-repository write group cleanup.
1090
 
        
1091
 
        This is called before the write group is considered to be 
 
1090
 
 
1091
        This is called before the write group is considered to be
1092
1092
        finished and should ensure that all data handed to the repository
1093
 
        for writing during the write group is safely committed (to the 
 
1093
        for writing during the write group is safely committed (to the
1094
1094
        extent possible considering file system caching etc).
1095
1095
        """
1096
1096
 
1105
1105
        self._resume_write_group(tokens)
1106
1106
        # so we can detect unlock/relock - the write group is now entered.
1107
1107
        self._write_group = self.get_transaction()
1108
 
    
 
1108
 
1109
1109
    def _resume_write_group(self, tokens):
1110
1110
        raise errors.UnsuspendableWriteGroup(self)
1111
1111
 
1139
1139
                           timezone=None, committer=None, revprops=None,
1140
1140
                           revision_id=None):
1141
1141
        """Obtain a CommitBuilder for this repository.
1142
 
        
 
1142
 
1143
1143
        :param branch: Branch to commit to.
1144
1144
        :param parents: Revision ids of the parents of the new revision.
1145
1145
        :param config: Configuration to use.
1207
1207
 
1208
1208
    def _start_write_group(self):
1209
1209
        """Template method for per-repository write group startup.
1210
 
        
1211
 
        This is called before the write group is considered to be 
 
1210
 
 
1211
        This is called before the write group is considered to be
1212
1212
        entered.
1213
1213
        """
1214
1214
 
1267
1267
    @needs_read_lock
1268
1268
    def get_revision_reconcile(self, revision_id):
1269
1269
        """'reconcile' helper routine that allows access to a revision always.
1270
 
        
 
1270
 
1271
1271
        This variant of get_revision does not cross check the weave graph
1272
1272
        against the revision one as get_revision does: but it should only
1273
1273
        be used by reconcile, or reconcile-alike commands that are correcting
1311
1311
 
1312
1312
    def get_deltas_for_revisions(self, revisions):
1313
1313
        """Produce a generator of revision deltas.
1314
 
        
 
1314
 
1315
1315
        Note that the input is a sequence of REVISIONS, not revision_ids.
1316
1316
        Trees will be held in memory until the generator exits.
1317
1317
        Each delta is relative to the revision's lefthand predecessor.
1320
1320
        for revision in revisions:
1321
1321
            required_trees.add(revision.revision_id)
1322
1322
            required_trees.update(revision.parent_ids[:1])
1323
 
        trees = dict((t.get_revision_id(), t) for 
 
1323
        trees = dict((t.get_revision_id(), t) for
1324
1324
                     t in self.revision_trees(required_trees))
1325
1325
        for revision in revisions:
1326
1326
            if not revision.parent_ids:
1391
1391
 
1392
1392
        # this code needs to read every new line in every inventory for the
1393
1393
        # inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
1394
 
        # not present in one of those inventories is unnecessary but not 
 
1394
        # not present in one of those inventories is unnecessary but not
1395
1395
        # harmful because we are filtering by the revision id marker in the
1396
 
        # inventory lines : we only select file ids altered in one of those  
 
1396
        # inventory lines : we only select file ids altered in one of those
1397
1397
        # revisions. We don't need to see all lines in the inventory because
1398
1398
        # only those added in an inventory in rev X can contain a revision=X
1399
1399
        # line.
1714
1714
            yield ''.join(chunks), key[-1]
1715
1715
 
1716
1716
    def deserialise_inventory(self, revision_id, xml):
1717
 
        """Transform the xml into an inventory object. 
 
1717
        """Transform the xml into an inventory object.
1718
1718
 
1719
1719
        :param revision_id: The expected revision id of the inventory.
1720
1720
        :param xml: A serialised inventory.
1822
1822
        # TODO: refactor this to use an existing revision object
1823
1823
        # so we don't need to read it in twice.
1824
1824
        if revision_id == _mod_revision.NULL_REVISION:
1825
 
            return RevisionTree(self, Inventory(root_id=None), 
 
1825
            return RevisionTree(self, Inventory(root_id=None),
1826
1826
                                _mod_revision.NULL_REVISION)
1827
1827
        else:
1828
1828
            inv = self.get_revision_inventory(revision_id)
1840
1840
    def get_ancestry(self, revision_id, topo_sorted=True):
1841
1841
        """Return a list of revision-ids integrated by a revision.
1842
1842
 
1843
 
        The first element of the list is always None, indicating the origin 
1844
 
        revision.  This might change when we have history horizons, or 
 
1843
        The first element of the list is always None, indicating the origin
 
1844
        revision.  This might change when we have history horizons, or
1845
1845
        perhaps we should have a new API.
1846
 
        
 
1846
 
1847
1847
        This is topologically sorted.
1848
1848
        """
1849
1849
        if _mod_revision.is_null(revision_id):
1873
1873
        types it should be a no-op that just returns.
1874
1874
 
1875
1875
        This stub method does not require a lock, but subclasses should use
1876
 
        @needs_write_lock as this is a long running call its reasonable to 
 
1876
        @needs_write_lock as this is a long running call its reasonable to
1877
1877
        implicitly lock for the user.
1878
1878
        """
1879
1879
 
1881
1881
    @deprecated_method(one_six)
1882
1882
    def print_file(self, file, revision_id):
1883
1883
        """Print `file` to stdout.
1884
 
        
 
1884
 
1885
1885
        FIXME RBC 20060125 as John Meinel points out this is a bad api
1886
1886
        - it writes to stdout, it assumes that that is valid etc. Fix
1887
1887
        by creating a new more flexible convenience function.
1967
1967
                          working trees.
1968
1968
        """
1969
1969
        raise NotImplementedError(self.set_make_working_trees)
1970
 
    
 
1970
 
1971
1971
    def make_working_trees(self):
1972
1972
        """Returns the policy for making working trees on new branches."""
1973
1973
        raise NotImplementedError(self.make_working_trees)
2038
2038
                    revision_id.decode('ascii')
2039
2039
                except UnicodeDecodeError:
2040
2040
                    raise errors.NonAsciiRevisionId(method, self)
2041
 
    
 
2041
 
2042
2042
    def revision_graph_can_have_wrong_parents(self):
2043
2043
        """Is it possible for this repository to have a revision graph with
2044
2044
        incorrect parents?
2162
2162
 
2163
2163
class MetaDirRepository(Repository):
2164
2164
    """Repositories in the new meta-dir layout.
2165
 
    
 
2165
 
2166
2166
    :ivar _transport: Transport for access to repository control files,
2167
2167
        typically pointing to .bzr/repository.
2168
2168
    """
2193
2193
        else:
2194
2194
            self._transport.put_bytes('no-working-trees', '',
2195
2195
                mode=self.bzrdir._get_file_mode())
2196
 
    
 
2196
 
2197
2197
    def make_working_trees(self):
2198
2198
        """Returns the policy for making working trees on new branches."""
2199
2199
        return not self._transport.has('no-working-trees')
2230
2230
        if callable(r):
2231
2231
            r = r()
2232
2232
        return r
2233
 
    
 
2233
 
2234
2234
 
2235
2235
network_format_registry = RepositoryFormatRegistry()
2236
2236
"""Registry of formats indexed by their network name.
2273
2273
    consistency.
2274
2274
 
2275
2275
    Once a format is deprecated, just deprecate the initialize and open
2276
 
    methods on the format class. Do not deprecate the object, as the 
 
2276
    methods on the format class. Do not deprecate the object, as the
2277
2277
    object may be created even when a repository instnace hasn't been
2278
2278
    created.
2279
2279
 
2304
2304
    @classmethod
2305
2305
    def find_format(klass, a_bzrdir):
2306
2306
        """Return the format for the repository object in a_bzrdir.
2307
 
        
 
2307
 
2308
2308
        This is used by bzr native formats that have a "format" file in
2309
 
        the repository.  Other methods may be used by different types of 
 
2309
        the repository.  Other methods may be used by different types of
2310
2310
        control directory.
2311
2311
        """
2312
2312
        try:
2326
2326
    @classmethod
2327
2327
    def unregister_format(klass, format):
2328
2328
        format_registry.remove(format.get_format_string())
2329
 
    
 
2329
 
2330
2330
    @classmethod
2331
2331
    def get_default_format(klass):
2332
2332
        """Return the current default format."""
2335
2335
 
2336
2336
    def get_format_string(self):
2337
2337
        """Return the ASCII format string that identifies this format.
2338
 
        
2339
 
        Note that in pre format ?? repositories the format string is 
 
2338
 
 
2339
        Note that in pre format ?? repositories the format string is
2340
2340
        not permitted nor written to disk.
2341
2341
        """
2342
2342
        raise NotImplementedError(self.get_format_string)
2373
2373
        :param a_bzrdir: The bzrdir to put the new repository in it.
2374
2374
        :param shared: The repository should be initialized as a sharable one.
2375
2375
        :returns: The new repository object.
2376
 
        
 
2376
 
2377
2377
        This may raise UninitializableFormat if shared repository are not
2378
2378
        compatible the a_bzrdir.
2379
2379
        """
2383
2383
        """Is this format supported?
2384
2384
 
2385
2385
        Supported formats must be initializable and openable.
2386
 
        Unsupported formats may not support initialization or committing or 
 
2386
        Unsupported formats may not support initialization or committing or
2387
2387
        some other features depending on the reason for not being supported.
2388
2388
        """
2389
2389
        return True
2403
2403
 
2404
2404
    def open(self, a_bzrdir, _found=False):
2405
2405
        """Return an instance of this format for the bzrdir a_bzrdir.
2406
 
        
 
2406
 
2407
2407
        _found is a private parameter, do not use it.
2408
2408
        """
2409
2409
        raise NotImplementedError(self.open)
2474
2474
)
2475
2475
 
2476
2476
# formats which have no format string are not discoverable or independently
2477
 
# creatable on disk, so are not registered in format_registry.  They're 
 
2477
# creatable on disk, so are not registered in format_registry.  They're
2478
2478
# all in bzrlib.repofmt.weaverepo now.  When an instance of one of these is
2479
2479
# needed, it's constructed directly by the BzrDir.  Non-native formats where
2480
2480
# the repository is not separately opened are similar.
2547
2547
    'RepositoryFormatKnitPack6RichRoot',
2548
2548
    )
2549
2549
 
2550
 
# Development formats. 
 
2550
# Development formats.
2551
2551
# 1.7->1.8 go below here
2552
2552
format_registry.register_lazy(
2553
2553
    "Bazaar development format 2 (needs bzr.dev from before 1.8)\n",
2566
2566
    """This class represents operations taking place between two repositories.
2567
2567
 
2568
2568
    Its instances have methods like copy_content and fetch, and contain
2569
 
    references to the source and target repositories these operations can be 
 
2569
    references to the source and target repositories these operations can be
2570
2570
    carried out on.
2571
2571
 
2572
2572
    Often we will provide convenience methods on 'repository' which carry out
2672
2672
    @needs_read_lock
2673
2673
    def missing_revision_ids(self, revision_id=None, find_ghosts=True):
2674
2674
        """Return the revision ids that source has that target does not.
2675
 
        
 
2675
 
2676
2676
        These are returned in topological order.
2677
2677
 
2678
2678
        :param revision_id: only return revision ids included by this
2686
2686
    @needs_read_lock
2687
2687
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
2688
2688
        """Return the revision ids that source has that target does not.
2689
 
        
 
2689
 
2690
2690
        :param revision_id: only return revision ids included by this
2691
2691
                            revision_id.
2692
2692
        :param find_ghosts: If True find missing revisions in deep history
2711
2711
    @staticmethod
2712
2712
    def _same_model(source, target):
2713
2713
        """True if source and target have the same data representation.
2714
 
        
 
2714
 
2715
2715
        Note: this is always called on the base class; overriding it in a
2716
2716
        subclass will have no effect.
2717
2717
        """
2735
2735
 
2736
2736
class InterSameDataRepository(InterRepository):
2737
2737
    """Code for converting between repositories that represent the same data.
2738
 
    
 
2738
 
2739
2739
    Data format and model must match for this to work.
2740
2740
    """
2741
2741
 
2742
2742
    @classmethod
2743
2743
    def _get_repo_format_to_test(self):
2744
2744
        """Repository format for testing with.
2745
 
        
 
2745
 
2746
2746
        InterSameData can pull from subtree to subtree and from non-subtree to
2747
2747
        non-subtree, so we test this with the richest repository format.
2748
2748
        """
2759
2759
 
2760
2760
        This copies both the repository's revision data, and configuration information
2761
2761
        such as the make_working_trees setting.
2762
 
        
2763
 
        This is a destructive operation! Do not use it on existing 
 
2762
 
 
2763
        This is a destructive operation! Do not use it on existing
2764
2764
        repositories.
2765
2765
 
2766
2766
        :param revision_id: Only copy the content needed to construct
2771
2771
        except NotImplementedError:
2772
2772
            pass
2773
2773
        # but don't bother fetching if we have the needed data now.
2774
 
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
2774
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and
2775
2775
            self.target.has_revision(revision_id)):
2776
2776
            return
2777
2777
        self.target.fetch(self.source, revision_id=revision_id)
2792
2792
 
2793
2793
class InterWeaveRepo(InterSameDataRepository):
2794
2794
    """Optimised code paths between Weave based repositories.
2795
 
    
 
2795
 
2796
2796
    This should be in bzrlib/repofmt/weaverepo.py but we have not yet
2797
2797
    implemented lazy inter-object optimisation.
2798
2798
    """
2805
2805
    @staticmethod
2806
2806
    def is_compatible(source, target):
2807
2807
        """Be compatible with known Weave formats.
2808
 
        
 
2808
 
2809
2809
        We don't test for the stores being of specific types because that
2810
 
        could lead to confusing results, and there is no need to be 
 
2810
        could lead to confusing results, and there is no need to be
2811
2811
        overly general.
2812
2812
        """
2813
2813
        from bzrlib.repofmt.weaverepo import (
2824
2824
                                                RepositoryFormat7)))
2825
2825
        except AttributeError:
2826
2826
            return False
2827
 
    
 
2827
 
2828
2828
    @needs_write_lock
2829
2829
    def copy_content(self, revision_id=None):
2830
2830
        """See InterRepository.copy_content()."""
2874
2874
        """See InterRepository.missing_revision_ids()."""
2875
2875
        # we want all revisions to satisfy revision_id in source.
2876
2876
        # but we don't want to stat every file here and there.
2877
 
        # we want then, all revisions other needs to satisfy revision_id 
 
2877
        # we want then, all revisions other needs to satisfy revision_id
2878
2878
        # checked, but not those that we have locally.
2879
 
        # so the first thing is to get a subset of the revisions to 
 
2879
        # so the first thing is to get a subset of the revisions to
2880
2880
        # satisfy revision_id in source, and then eliminate those that
2881
 
        # we do already have. 
 
2881
        # we do already have.
2882
2882
        # this is slow on high latency connection to self, but as as this
2883
 
        # disk format scales terribly for push anyway due to rewriting 
 
2883
        # disk format scales terribly for push anyway due to rewriting
2884
2884
        # inventory.weave, this is considered acceptable.
2885
2885
        # - RBC 20060209
2886
2886
        if revision_id is not None:
2906
2906
            # and the tip revision was validated by get_ancestry.
2907
2907
            result_set = required_revisions
2908
2908
        else:
2909
 
            # if we just grabbed the possibly available ids, then 
 
2909
            # if we just grabbed the possibly available ids, then
2910
2910
            # we only have an estimate of whats available and need to validate
2911
2911
            # that against the revision records.
2912
2912
            result_set = set(
2925
2925
    @staticmethod
2926
2926
    def is_compatible(source, target):
2927
2927
        """Be compatible with known Knit formats.
2928
 
        
 
2928
 
2929
2929
        We don't test for the stores being of specific types because that
2930
 
        could lead to confusing results, and there is no need to be 
 
2930
        could lead to confusing results, and there is no need to be
2931
2931
        overly general.
2932
2932
        """
2933
2933
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit
2976
2976
            # and the tip revision was validated by get_ancestry.
2977
2977
            result_set = required_revisions
2978
2978
        else:
2979
 
            # if we just grabbed the possibly available ids, then 
 
2979
            # if we just grabbed the possibly available ids, then
2980
2980
            # we only have an estimate of whats available and need to validate
2981
2981
            # that against the revision records.
2982
2982
            result_set = set(
2995
2995
    @staticmethod
2996
2996
    def is_compatible(source, target):
2997
2997
        """Be compatible with known Pack formats.
2998
 
        
 
2998
 
2999
2999
        We don't test for the stores being of specific types because that
3000
 
        could lead to confusing results, and there is no need to be 
 
3000
        could lead to confusing results, and there is no need to be
3001
3001
        overly general.
3002
3002
        """
3003
3003
        from bzrlib.repofmt.pack_repo import RepositoryFormatPack
3078
3078
 
3079
3079
    def _autopack(self):
3080
3080
        self.target._pack_collection.autopack()
3081
 
        
 
3081
 
3082
3082
    def _get_target_pack_collection(self):
3083
3083
        return self.target._pack_collection
3084
3084
 
3085
3085
    @needs_read_lock
3086
3086
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
3087
3087
        """See InterRepository.missing_revision_ids().
3088
 
        
 
3088
 
3089
3089
        :param find_ghosts: Find ghosts throughout the ancestry of
3090
3090
            revision_id.
3091
3091
        """
3148
3148
    @needs_write_lock
3149
3149
    def copy_content(self, revision_id=None):
3150
3150
        """Make a complete copy of the content in self into destination.
3151
 
        
3152
 
        This is a destructive operation! Do not use it on existing 
 
3151
 
 
3152
        This is a destructive operation! Do not use it on existing
3153
3153
        repositories.
3154
3154
 
3155
3155
        :param revision_id: Only copy the content needed to construct
3160
3160
        except NotImplementedError:
3161
3161
            pass
3162
3162
        # but don't bother fetching if we have the needed data now.
3163
 
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
3163
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and
3164
3164
            self.target.has_revision(revision_id)):
3165
3165
            return
3166
3166
        self.target.fetch(self.source, revision_id=revision_id)
3230
3230
        """See InterRepository.fetch()."""
3231
3231
        from bzrlib.fetch import Knit1to2Fetcher
3232
3232
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
3233
 
               self.source, self.source._format, self.target, 
 
3233
               self.source, self.source._format, self.target,
3234
3234
               self.target._format)
3235
3235
        f = Knit1to2Fetcher(to_repository=self.target,
3236
3236
                            from_repository=self.source,
3409
3409
            # Make _real_inter use the RemoteRepository for get_parent_map
3410
3410
            self._real_inter.target_get_graph = self.target.get_graph
3411
3411
            self._real_inter.target_get_parent_map = self.target.get_parent_map
3412
 
    
 
3412
 
3413
3413
    def copy_content(self, revision_id=None):
3414
3414
        self._ensure_real_inter()
3415
3415
        self._real_inter.copy_content(revision_id=revision_id)
3447
3447
            self.source._ensure_real()
3448
3448
            real_source = self.source._real_repository
3449
3449
            self._real_inter = InterRepository.get(real_source, self.target)
3450
 
    
 
3450
 
3451
3451
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
3452
3452
        self._ensure_real_inter()
3453
3453
        return self._real_inter.fetch(revision_id=revision_id, pb=pb,
3484
3484
                    if InterRepository._same_model(source, target):
3485
3485
                        return True
3486
3486
        return False
3487
 
    
 
3487
 
3488
3488
    def _autopack(self):
3489
3489
        self.target.autopack()
3490
3490
 
3497
3497
        fetcher = RepoFetcher(self.target, self.source, revision_id,
3498
3498
                              pb, find_ghosts)
3499
3499
        return fetcher.count_copied, fetcher.failed_revisions
3500
 
        
 
3500
 
3501
3501
    def _get_target_pack_collection(self):
3502
3502
        return self.target._real_repository._pack_collection
3503
3503
 
3520
3520
 
3521
3521
class CopyConverter(object):
3522
3522
    """A repository conversion tool which just performs a copy of the content.
3523
 
    
 
3523
 
3524
3524
    This is slow but quite reliable.
3525
3525
    """
3526
3526
 
3530
3530
        :param target_format: The format the resulting repository should be.
3531
3531
        """
3532
3532
        self.target_format = target_format
3533
 
        
 
3533
 
3534
3534
    def convert(self, repo, pb):
3535
3535
        """Perform the conversion of to_convert, giving feedback via pb.
3536
3536
 
3605
3605
    def __init__(self, repository):
3606
3606
        self.repository = repository
3607
3607
        self.text_index = self.repository._generate_text_key_index()
3608
 
    
 
3608
 
3609
3609
    def calculate_file_version_parents(self, text_key):
3610
3610
        """Calculate the correct parents for a file version according to
3611
3611
        the inventories.
3725
3725
 
3726
3726
    def _extract_and_insert_inventories(self, substream, serializer):
3727
3727
        """Generate a new inventory versionedfile in target, converting data.
3728
 
        
 
3728
 
3729
3729
        The inventory is retrieved from the source, (deserializing it), and
3730
3730
        stored in the target (reserializing it in a different format).
3731
3731
        """