← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 04:02:41 UTC
  • mfrom: (5017.2.2 tariff)
  • Revision ID: pqm@pqm.ubuntu.com-20100211040241-w6n021dz0uus341n
(mbp) add import-tariff tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
40
40
    lru_cache,
41
41
    osutils,
42
42
    revision as _mod_revision,
43
 
    static_tuple,
44
43
    symbol_versioning,
45
44
    trace,
46
45
    tsort,
864
863
# Repositories
865
864
 
866
865
 
867
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
866
class Repository(_RelockDebugMixin):
868
867
    """Repository holding history for one or more branches.
869
868
 
870
869
    The repository holds and retrieves historical information including
1028
1027
 
1029
1028
        :seealso: add_inventory, for the contract.
1030
1029
        """
1031
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1030
        inv_lines = self._serialise_inventory_to_lines(inv)
1032
1031
        return self._inventory_add_lines(revision_id, parents,
1033
1032
            inv_lines, check_content=False)
1034
1033
 
1291
1290
 
1292
1291
        :param _format: The format of the repository on disk.
1293
1292
        :param a_bzrdir: The BzrDir of the repository.
 
1293
 
 
1294
        In the future we will have a single api for all stores for
 
1295
        getting file texts, inventories and revisions, then
 
1296
        this construct will accept instances of those things.
1294
1297
        """
1295
 
        # In the future we will have a single api for all stores for
1296
 
        # getting file texts, inventories and revisions, then
1297
 
        # this construct will accept instances of those things.
1298
1298
        super(Repository, self).__init__()
1299
1299
        self._format = _format
1300
1300
        # the following are part of the public API for Repository:
1315
1315
        # rather copying them?
1316
1316
        self._safe_to_return_from_cache = False
1317
1317
 
1318
 
    @property
1319
 
    def user_transport(self):
1320
 
        return self.bzrdir.user_transport
1321
 
 
1322
 
    @property
1323
 
    def control_transport(self):
1324
 
        return self._transport
1325
 
 
1326
1318
    def __repr__(self):
1327
1319
        if self._fallback_repositories:
1328
1320
            return '%s(%r, fallback_repositories=%r)' % (
1476
1468
 
1477
1469
        # now gather global repository information
1478
1470
        # XXX: This is available for many repos regardless of listability.
1479
 
        if self.user_transport.listable():
 
1471
        if self.bzrdir.root_transport.listable():
1480
1472
            # XXX: do we want to __define len__() ?
1481
1473
            # Maybe the versionedfiles object should provide a different
1482
1474
            # method to get the number of keys.
1492
1484
        :param using: If True, list only branches using this repository.
1493
1485
        """
1494
1486
        if using and not self.is_shared():
1495
 
            return self.bzrdir.list_branches()
 
1487
            try:
 
1488
                return [self.bzrdir.open_branch()]
 
1489
            except errors.NotBranchError:
 
1490
                return []
1496
1491
        class Evaluator(object):
1497
1492
 
1498
1493
            def __init__(self):
1507
1502
                    except errors.NoRepositoryPresent:
1508
1503
                        pass
1509
1504
                    else:
1510
 
                        return False, ([], repository)
 
1505
                        return False, (None, repository)
1511
1506
                self.first_call = False
1512
 
                value = (bzrdir.list_branches(), None)
 
1507
                try:
 
1508
                    value = (bzrdir.open_branch(), None)
 
1509
                except errors.NotBranchError:
 
1510
                    value = (None, None)
1513
1511
                return True, value
1514
1512
 
1515
 
        ret = []
1516
 
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1517
 
                self.user_transport, evaluate=Evaluator()):
1518
 
            if branches is not None:
1519
 
                ret.extend(branches)
 
1513
        branches = []
 
1514
        for branch, repository in bzrdir.BzrDir.find_bzrdirs(
 
1515
                self.bzrdir.root_transport, evaluate=Evaluator()):
 
1516
            if branch is not None:
 
1517
                branches.append(branch)
1520
1518
            if not using and repository is not None:
1521
 
                ret.extend(repository.find_branches())
1522
 
        return ret
 
1519
                branches.extend(repository.find_branches())
 
1520
        return branches
1523
1521
 
1524
1522
    @needs_read_lock
1525
1523
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1903
1901
                rev = self._serializer.read_revision_from_string(text)
1904
1902
                yield (revid, rev)
1905
1903
 
 
1904
    @needs_read_lock
 
1905
    def get_revision_xml(self, revision_id):
 
1906
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1907
        #       would have already do it.
 
1908
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1909
        # TODO: this can't just be replaced by:
 
1910
        # return self._serializer.write_revision_to_string(
 
1911
        #     self.get_revision(revision_id))
 
1912
        # as cStringIO preservers the encoding unlike write_revision_to_string
 
1913
        # or some other call down the path.
 
1914
        rev = self.get_revision(revision_id)
 
1915
        rev_tmp = cStringIO.StringIO()
 
1916
        # the current serializer..
 
1917
        self._serializer.write_revision(rev, rev_tmp)
 
1918
        rev_tmp.seek(0)
 
1919
        return rev_tmp.getvalue()
 
1920
 
1906
1921
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1907
1922
        """Produce a generator of revision deltas.
1908
1923
 
2421
2436
                result.revision_id, revision_id))
2422
2437
        return result
2423
2438
 
 
2439
    def _serialise_inventory(self, inv):
 
2440
        return self._serializer.write_inventory_to_string(inv)
 
2441
 
 
2442
    def _serialise_inventory_to_lines(self, inv):
 
2443
        return self._serializer.write_inventory_to_lines(inv)
 
2444
 
2424
2445
    def get_serializer_format(self):
2425
2446
        return self._serializer.format_num
2426
2447
 
2490
2511
            else:
2491
2512
                next_id = parents[0]
2492
2513
 
 
2514
    @needs_read_lock
 
2515
    def get_revision_inventory(self, revision_id):
 
2516
        """Return inventory of a past revision."""
 
2517
        # TODO: Unify this with get_inventory()
 
2518
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
2519
        # must be the same as its revision, so this is trivial.
 
2520
        if revision_id is None:
 
2521
            # This does not make sense: if there is no revision,
 
2522
            # then it is the current tree inventory surely ?!
 
2523
            # and thus get_root_id() is something that looks at the last
 
2524
            # commit on the branch, and the get_root_id is an inventory check.
 
2525
            raise NotImplementedError
 
2526
            # return Inventory(self.get_root_id())
 
2527
        else:
 
2528
            return self.get_inventory(revision_id)
 
2529
 
2493
2530
    def is_shared(self):
2494
2531
        """Return True if this repository is flagged as a shared repository."""
2495
2532
        raise NotImplementedError(self.is_shared)
2529
2566
            return RevisionTree(self, Inventory(root_id=None),
2530
2567
                                _mod_revision.NULL_REVISION)
2531
2568
        else:
2532
 
            inv = self.get_inventory(revision_id)
 
2569
            inv = self.get_revision_inventory(revision_id)
2533
2570
            return RevisionTree(self, inv, revision_id)
2534
2571
 
2535
2572
    def revision_trees(self, revision_ids):
2588
2625
            keys = tsort.topo_sort(parent_map)
2589
2626
        return [None] + list(keys)
2590
2627
 
2591
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2628
    def pack(self, hint=None):
2592
2629
        """Compress the data within the repository.
2593
2630
 
2594
2631
        This operation only makes sense for some repository types. For other
2604
2641
            obtained from the result of commit_write_group(). Out of
2605
2642
            date hints are simply ignored, because concurrent operations
2606
2643
            can obsolete them rapidly.
2607
 
 
2608
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2609
 
            the pack operation.
2610
2644
        """
2611
2645
 
2612
2646
    def get_transaction(self):
2637
2671
    def _make_parents_provider(self):
2638
2672
        return self
2639
2673
 
2640
 
    @needs_read_lock
2641
 
    def get_known_graph_ancestry(self, revision_ids):
2642
 
        """Return the known graph for a set of revision ids and their ancestors.
2643
 
        """
2644
 
        st = static_tuple.StaticTuple
2645
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
2646
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2647
 
        return graph.GraphThunkIdsToKeys(known_graph)
2648
 
 
2649
2674
    def get_graph(self, other_repository=None):
2650
2675
        """Return the graph walker for this repository format"""
2651
2676
        parents_provider = self._make_parents_provider()
3053
3078
    # Is the format experimental ?
3054
3079
    experimental = False
3055
3080
 
3056
 
    def __repr__(self):
3057
 
        return "%s()" % self.__class__.__name__
 
3081
    def __str__(self):
 
3082
        return "<%s>" % self.__class__.__name__
3058
3083
 
3059
3084
    def __eq__(self, other):
3060
3085
        # format objects are generally stateless
3178
3203
        """
3179
3204
        raise NotImplementedError(self.open)
3180
3205
 
3181
 
    def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3182
 
        from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3183
 
        hooks = BzrDir.hooks['post_repo_init']
3184
 
        if not hooks:
3185
 
            return
3186
 
        params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3187
 
        for hook in hooks:
3188
 
            hook(params)
3189
 
 
3190
3206
 
3191
3207
class MetaDirRepositoryFormat(RepositoryFormat):
3192
3208
    """Common base class for the new repositories using the metadir layout."""
3401
3417
        :return: None.
3402
3418
        """
3403
3419
        ui.ui_factory.warn_experimental_format_fetch(self)
3404
 
        from bzrlib.fetch import RepoFetcher
3405
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
3406
 
        if self.source._format.network_name() != self.target._format.network_name():
3407
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
3408
 
                from_format=self.source._format,
3409
 
                to_format=self.target._format)
3410
 
        f = RepoFetcher(to_repository=self.target,
 
3420
        f = _mod_fetch.RepoFetcher(to_repository=self.target,
3411
3421
                               from_repository=self.source,
3412
3422
                               last_revision=revision_id,
3413
3423
                               fetch_spec=fetch_spec,
3991
4001
        """See InterRepository.fetch()."""
3992
4002
        if fetch_spec is not None:
3993
4003
            raise AssertionError("Not implemented yet...")
 
4004
        # See <https://launchpad.net/bugs/456077> asking for a warning here
 
4005
        #
 
4006
        # nb this is only active for local-local fetches; other things using
 
4007
        # streaming.
 
4008
        ui.ui_factory.warn_cross_format_fetch(self.source._format,
 
4009
            self.target._format)
3994
4010
        ui.ui_factory.warn_experimental_format_fetch(self)
3995
4011
        if (not self.source.supports_rich_root()
3996
4012
            and self.target.supports_rich_root()):
3998
4014
            self._revision_id_to_root_id = {}
3999
4015
        else:
4000
4016
            self._converting_to_rich_root = False
4001
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
4002
 
        if self.source._format.network_name() != self.target._format.network_name():
4003
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
4004
 
                from_format=self.source._format,
4005
 
                to_format=self.target._format)
4006
4017
        revision_ids = self.target.search_missing_revision_ids(self.source,
4007
4018
            revision_id, find_ghosts=find_ghosts).get_keys()
4008
4019
        if not revision_ids:
4291
4302
                    self._extract_and_insert_inventories(
4292
4303
                        substream, src_serializer)
4293
4304
            elif substream_type == 'inventory-deltas':
 
4305
                ui.ui_factory.warn_cross_format_fetch(src_format,
 
4306
                    self.target_repo._format)
4294
4307
                self._extract_and_insert_inventory_deltas(
4295
4308
                    substream, src_serializer)
4296
4309
            elif substream_type == 'chk_bytes':