/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: 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,
61
60
    ROOT_ID,
62
61
    entry_factory,
63
62
    )
64
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
63
from bzrlib.lock import _RelockDebugMixin
65
64
from bzrlib import registry
66
65
from bzrlib.trace import (
67
66
    log_exception_quietly, note, mutter, mutter_callsite, warning)
860
859
        # versioned roots do not change unless the tree found a change.
861
860
 
862
861
 
863
 
class RepositoryWriteLockResult(LogicalLockResult):
864
 
    """The result of write locking a repository.
865
 
 
866
 
    :ivar repository_token: The token obtained from the underlying lock, or
867
 
        None.
868
 
    :ivar unlock: A callable which will unlock the lock.
869
 
    """
870
 
 
871
 
    def __init__(self, unlock, repository_token):
872
 
        LogicalLockResult.__init__(self, unlock)
873
 
        self.repository_token = repository_token
874
 
 
875
 
    def __repr__(self):
876
 
        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
877
 
            self.unlock)
878
 
 
879
 
 
880
862
######################################################################
881
863
# Repositories
882
864
 
883
865
 
884
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
866
class Repository(_RelockDebugMixin):
885
867
    """Repository holding history for one or more branches.
886
868
 
887
869
    The repository holds and retrieves historical information including
1045
1027
 
1046
1028
        :seealso: add_inventory, for the contract.
1047
1029
        """
1048
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1030
        inv_lines = self._serialise_inventory_to_lines(inv)
1049
1031
        return self._inventory_add_lines(revision_id, parents,
1050
1032
            inv_lines, check_content=False)
1051
1033
 
1308
1290
 
1309
1291
        :param _format: The format of the repository on disk.
1310
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.
1311
1297
        """
1312
 
        # In the future we will have a single api for all stores for
1313
 
        # getting file texts, inventories and revisions, then
1314
 
        # this construct will accept instances of those things.
1315
1298
        super(Repository, self).__init__()
1316
1299
        self._format = _format
1317
1300
        # the following are part of the public API for Repository:
1332
1315
        # rather copying them?
1333
1316
        self._safe_to_return_from_cache = False
1334
1317
 
1335
 
    @property
1336
 
    def user_transport(self):
1337
 
        return self.bzrdir.user_transport
1338
 
 
1339
 
    @property
1340
 
    def control_transport(self):
1341
 
        return self._transport
1342
 
 
1343
1318
    def __repr__(self):
1344
1319
        if self._fallback_repositories:
1345
1320
            return '%s(%r, fallback_repositories=%r)' % (
1393
1368
        data during reads, and allows a 'write_group' to be obtained. Write
1394
1369
        groups must be used for actual data insertion.
1395
1370
 
1396
 
        A token should be passed in if you know that you have locked the object
1397
 
        some other way, and need to synchronise this object's state with that
1398
 
        fact.
1399
 
 
1400
 
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1401
 
 
1402
1371
        :param token: if this is already locked, then lock_write will fail
1403
1372
            unless the token matches the existing lock.
1404
1373
        :returns: a token if this instance supports tokens, otherwise None.
1407
1376
        :raises MismatchedToken: if the specified token doesn't match the token
1408
1377
            of the existing lock.
1409
1378
        :seealso: start_write_group.
1410
 
        :return: A RepositoryWriteLockResult.
 
1379
 
 
1380
        A token should be passed in if you know that you have locked the object
 
1381
        some other way, and need to synchronise this object's state with that
 
1382
        fact.
 
1383
 
 
1384
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1411
1385
        """
1412
1386
        locked = self.is_locked()
1413
 
        token = self.control_files.lock_write(token=token)
 
1387
        result = self.control_files.lock_write(token=token)
1414
1388
        if not locked:
1415
1389
            self._warn_if_deprecated()
1416
1390
            self._note_lock('w')
1418
1392
                # Writes don't affect fallback repos
1419
1393
                repo.lock_read()
1420
1394
            self._refresh_data()
1421
 
        return RepositoryWriteLockResult(self.unlock, token)
 
1395
        return result
1422
1396
 
1423
1397
    def lock_read(self):
1424
 
        """Lock the repository for read operations.
1425
 
 
1426
 
        :return: An object with an unlock method which will release the lock
1427
 
            obtained.
1428
 
        """
1429
1398
        locked = self.is_locked()
1430
1399
        self.control_files.lock_read()
1431
1400
        if not locked:
1434
1403
            for repo in self._fallback_repositories:
1435
1404
                repo.lock_read()
1436
1405
            self._refresh_data()
1437
 
        return LogicalLockResult(self.unlock)
1438
1406
 
1439
1407
    def get_physical_lock_status(self):
1440
1408
        return self.control_files.get_physical_lock_status()
1500
1468
 
1501
1469
        # now gather global repository information
1502
1470
        # XXX: This is available for many repos regardless of listability.
1503
 
        if self.user_transport.listable():
 
1471
        if self.bzrdir.root_transport.listable():
1504
1472
            # XXX: do we want to __define len__() ?
1505
1473
            # Maybe the versionedfiles object should provide a different
1506
1474
            # method to get the number of keys.
1516
1484
        :param using: If True, list only branches using this repository.
1517
1485
        """
1518
1486
        if using and not self.is_shared():
1519
 
            return self.bzrdir.list_branches()
 
1487
            try:
 
1488
                return [self.bzrdir.open_branch()]
 
1489
            except errors.NotBranchError:
 
1490
                return []
1520
1491
        class Evaluator(object):
1521
1492
 
1522
1493
            def __init__(self):
1531
1502
                    except errors.NoRepositoryPresent:
1532
1503
                        pass
1533
1504
                    else:
1534
 
                        return False, ([], repository)
 
1505
                        return False, (None, repository)
1535
1506
                self.first_call = False
1536
 
                value = (bzrdir.list_branches(), None)
 
1507
                try:
 
1508
                    value = (bzrdir.open_branch(), None)
 
1509
                except errors.NotBranchError:
 
1510
                    value = (None, None)
1537
1511
                return True, value
1538
1512
 
1539
 
        ret = []
1540
 
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1541
 
                self.user_transport, evaluate=Evaluator()):
1542
 
            if branches is not None:
1543
 
                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)
1544
1518
            if not using and repository is not None:
1545
 
                ret.extend(repository.find_branches())
1546
 
        return ret
 
1519
                branches.extend(repository.find_branches())
 
1520
        return branches
1547
1521
 
1548
1522
    @needs_read_lock
1549
1523
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1927
1901
                rev = self._serializer.read_revision_from_string(text)
1928
1902
                yield (revid, rev)
1929
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
 
1930
1921
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1931
1922
        """Produce a generator of revision deltas.
1932
1923
 
2445
2436
                result.revision_id, revision_id))
2446
2437
        return result
2447
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
 
2448
2445
    def get_serializer_format(self):
2449
2446
        return self._serializer.format_num
2450
2447
 
2514
2511
            else:
2515
2512
                next_id = parents[0]
2516
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
 
2517
2530
    def is_shared(self):
2518
2531
        """Return True if this repository is flagged as a shared repository."""
2519
2532
        raise NotImplementedError(self.is_shared)
2553
2566
            return RevisionTree(self, Inventory(root_id=None),
2554
2567
                                _mod_revision.NULL_REVISION)
2555
2568
        else:
2556
 
            inv = self.get_inventory(revision_id)
 
2569
            inv = self.get_revision_inventory(revision_id)
2557
2570
            return RevisionTree(self, inv, revision_id)
2558
2571
 
2559
2572
    def revision_trees(self, revision_ids):
2612
2625
            keys = tsort.topo_sort(parent_map)
2613
2626
        return [None] + list(keys)
2614
2627
 
2615
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2628
    def pack(self, hint=None):
2616
2629
        """Compress the data within the repository.
2617
2630
 
2618
2631
        This operation only makes sense for some repository types. For other
2628
2641
            obtained from the result of commit_write_group(). Out of
2629
2642
            date hints are simply ignored, because concurrent operations
2630
2643
            can obsolete them rapidly.
2631
 
 
2632
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2633
 
            the pack operation.
2634
2644
        """
2635
2645
 
2636
2646
    def get_transaction(self):
2661
2671
    def _make_parents_provider(self):
2662
2672
        return self
2663
2673
 
2664
 
    @needs_read_lock
2665
 
    def get_known_graph_ancestry(self, revision_ids):
2666
 
        """Return the known graph for a set of revision ids and their ancestors.
2667
 
        """
2668
 
        st = static_tuple.StaticTuple
2669
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
2670
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2671
 
        return graph.GraphThunkIdsToKeys(known_graph)
2672
 
 
2673
2674
    def get_graph(self, other_repository=None):
2674
2675
        """Return the graph walker for this repository format"""
2675
2676
        parents_provider = self._make_parents_provider()
3077
3078
    # Is the format experimental ?
3078
3079
    experimental = False
3079
3080
 
3080
 
    def __repr__(self):
3081
 
        return "%s()" % self.__class__.__name__
 
3081
    def __str__(self):
 
3082
        return "<%s>" % self.__class__.__name__
3082
3083
 
3083
3084
    def __eq__(self, other):
3084
3085
        # format objects are generally stateless
3202
3203
        """
3203
3204
        raise NotImplementedError(self.open)
3204
3205
 
3205
 
    def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3206
 
        from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3207
 
        hooks = BzrDir.hooks['post_repo_init']
3208
 
        if not hooks:
3209
 
            return
3210
 
        params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3211
 
        for hook in hooks:
3212
 
            hook(params)
3213
 
 
3214
3206
 
3215
3207
class MetaDirRepositoryFormat(RepositoryFormat):
3216
3208
    """Common base class for the new repositories using the metadir layout."""
3425
3417
        :return: None.
3426
3418
        """
3427
3419
        ui.ui_factory.warn_experimental_format_fetch(self)
3428
 
        from bzrlib.fetch import RepoFetcher
3429
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
3430
 
        if self.source._format.network_name() != self.target._format.network_name():
3431
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
3432
 
                from_format=self.source._format,
3433
 
                to_format=self.target._format)
3434
 
        f = RepoFetcher(to_repository=self.target,
 
3420
        f = _mod_fetch.RepoFetcher(to_repository=self.target,
3435
3421
                               from_repository=self.source,
3436
3422
                               last_revision=revision_id,
3437
3423
                               fetch_spec=fetch_spec,
4015
4001
        """See InterRepository.fetch()."""
4016
4002
        if fetch_spec is not None:
4017
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)
4018
4010
        ui.ui_factory.warn_experimental_format_fetch(self)
4019
4011
        if (not self.source.supports_rich_root()
4020
4012
            and self.target.supports_rich_root()):
4022
4014
            self._revision_id_to_root_id = {}
4023
4015
        else:
4024
4016
            self._converting_to_rich_root = False
4025
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
4026
 
        if self.source._format.network_name() != self.target._format.network_name():
4027
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
4028
 
                from_format=self.source._format,
4029
 
                to_format=self.target._format)
4030
4017
        revision_ids = self.target.search_missing_revision_ids(self.source,
4031
4018
            revision_id, find_ghosts=find_ghosts).get_keys()
4032
4019
        if not revision_ids:
4315
4302
                    self._extract_and_insert_inventories(
4316
4303
                        substream, src_serializer)
4317
4304
            elif substream_type == 'inventory-deltas':
 
4305
                ui.ui_factory.warn_cross_format_fetch(src_format,
 
4306
                    self.target_repo._format)
4318
4307
                self._extract_and_insert_inventory_deltas(
4319
4308
                    substream, src_serializer)
4320
4309
            elif substream_type == 'chk_bytes':