/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Martin Pool
  • Date: 2010-02-18 04:17:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5051.
  • Revision ID: mbp@sourcefrog.net-20100218041722-qmx7bz11qkeeh0nn
Link to commonly-duped bugs

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
26
26
    chk_map,
27
27
    config,
28
28
    debug,
 
29
    errors,
29
30
    fetch as _mod_fetch,
30
31
    fifo_cache,
31
32
    generate_ids,
39
40
    lru_cache,
40
41
    osutils,
41
42
    revision as _mod_revision,
42
 
    static_tuple,
43
43
    symbol_versioning,
44
44
    trace,
45
45
    tsort,
52
52
from bzrlib.testament import Testament
53
53
""")
54
54
 
55
 
from bzrlib import (
56
 
    errors,
57
 
    registry,
58
 
    )
59
55
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
60
56
from bzrlib.inter import InterObject
61
57
from bzrlib.inventory import (
64
60
    ROOT_ID,
65
61
    entry_factory,
66
62
    )
67
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
63
from bzrlib.lock import _RelockDebugMixin
 
64
from bzrlib import registry
68
65
from bzrlib.trace import (
69
66
    log_exception_quietly, note, mutter, mutter_callsite, warning)
70
67
 
73
70
_deprecation_warning_done = False
74
71
 
75
72
 
76
 
class IsInWriteGroupError(errors.InternalBzrError):
77
 
 
78
 
    _fmt = "May not refresh_data of repo %(repo)s while in a write group."
79
 
 
80
 
    def __init__(self, repo):
81
 
        errors.InternalBzrError.__init__(self, repo=repo)
82
 
 
83
 
 
84
73
class CommitBuilder(object):
85
74
    """Provides an interface to build up a commit.
86
75
 
870
859
        # versioned roots do not change unless the tree found a change.
871
860
 
872
861
 
873
 
class RepositoryWriteLockResult(LogicalLockResult):
874
 
    """The result of write locking a repository.
875
 
 
876
 
    :ivar repository_token: The token obtained from the underlying lock, or
877
 
        None.
878
 
    :ivar unlock: A callable which will unlock the lock.
879
 
    """
880
 
 
881
 
    def __init__(self, unlock, repository_token):
882
 
        LogicalLockResult.__init__(self, unlock)
883
 
        self.repository_token = repository_token
884
 
 
885
 
    def __repr__(self):
886
 
        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
887
 
            self.unlock)
888
 
 
889
 
 
890
862
######################################################################
891
863
# Repositories
892
864
 
893
865
 
894
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
866
class Repository(_RelockDebugMixin):
895
867
    """Repository holding history for one or more branches.
896
868
 
897
869
    The repository holds and retrieves historical information including
1055
1027
 
1056
1028
        :seealso: add_inventory, for the contract.
1057
1029
        """
1058
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1030
        inv_lines = self._serialise_inventory_to_lines(inv)
1059
1031
        return self._inventory_add_lines(revision_id, parents,
1060
1032
            inv_lines, check_content=False)
1061
1033
 
1318
1290
 
1319
1291
        :param _format: The format of the repository on disk.
1320
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.
1321
1297
        """
1322
 
        # In the future we will have a single api for all stores for
1323
 
        # getting file texts, inventories and revisions, then
1324
 
        # this construct will accept instances of those things.
1325
1298
        super(Repository, self).__init__()
1326
1299
        self._format = _format
1327
1300
        # the following are part of the public API for Repository:
1342
1315
        # rather copying them?
1343
1316
        self._safe_to_return_from_cache = False
1344
1317
 
1345
 
    @property
1346
 
    def user_transport(self):
1347
 
        return self.bzrdir.user_transport
1348
 
 
1349
 
    @property
1350
 
    def control_transport(self):
1351
 
        return self._transport
1352
 
 
1353
1318
    def __repr__(self):
1354
1319
        if self._fallback_repositories:
1355
1320
            return '%s(%r, fallback_repositories=%r)' % (
1403
1368
        data during reads, and allows a 'write_group' to be obtained. Write
1404
1369
        groups must be used for actual data insertion.
1405
1370
 
1406
 
        A token should be passed in if you know that you have locked the object
1407
 
        some other way, and need to synchronise this object's state with that
1408
 
        fact.
1409
 
 
1410
 
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1411
 
 
1412
1371
        :param token: if this is already locked, then lock_write will fail
1413
1372
            unless the token matches the existing lock.
1414
1373
        :returns: a token if this instance supports tokens, otherwise None.
1417
1376
        :raises MismatchedToken: if the specified token doesn't match the token
1418
1377
            of the existing lock.
1419
1378
        :seealso: start_write_group.
1420
 
        :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
1421
1385
        """
1422
1386
        locked = self.is_locked()
1423
 
        token = self.control_files.lock_write(token=token)
 
1387
        result = self.control_files.lock_write(token=token)
1424
1388
        if not locked:
1425
1389
            self._warn_if_deprecated()
1426
1390
            self._note_lock('w')
1428
1392
                # Writes don't affect fallback repos
1429
1393
                repo.lock_read()
1430
1394
            self._refresh_data()
1431
 
        return RepositoryWriteLockResult(self.unlock, token)
 
1395
        return result
1432
1396
 
1433
1397
    def lock_read(self):
1434
 
        """Lock the repository for read operations.
1435
 
 
1436
 
        :return: An object with an unlock method which will release the lock
1437
 
            obtained.
1438
 
        """
1439
1398
        locked = self.is_locked()
1440
1399
        self.control_files.lock_read()
1441
1400
        if not locked:
1444
1403
            for repo in self._fallback_repositories:
1445
1404
                repo.lock_read()
1446
1405
            self._refresh_data()
1447
 
        return LogicalLockResult(self.unlock)
1448
1406
 
1449
1407
    def get_physical_lock_status(self):
1450
1408
        return self.control_files.get_physical_lock_status()
1510
1468
 
1511
1469
        # now gather global repository information
1512
1470
        # XXX: This is available for many repos regardless of listability.
1513
 
        if self.user_transport.listable():
 
1471
        if self.bzrdir.root_transport.listable():
1514
1472
            # XXX: do we want to __define len__() ?
1515
1473
            # Maybe the versionedfiles object should provide a different
1516
1474
            # method to get the number of keys.
1548
1506
 
1549
1507
        ret = []
1550
1508
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1551
 
                self.user_transport, evaluate=Evaluator()):
 
1509
                self.bzrdir.root_transport, evaluate=Evaluator()):
1552
1510
            if branches is not None:
1553
1511
                ret.extend(branches)
1554
1512
            if not using and repository is not None:
1668
1626
        return missing_keys
1669
1627
 
1670
1628
    def refresh_data(self):
1671
 
        """Re-read any data needed to synchronise with disk.
 
1629
        """Re-read any data needed to to synchronise with disk.
1672
1630
 
1673
1631
        This method is intended to be called after another repository instance
1674
1632
        (such as one used by a smart server) has inserted data into the
1675
 
        repository. On all repositories this will work outside of write groups.
1676
 
        Some repository formats (pack and newer for bzrlib native formats)
1677
 
        support refresh_data inside write groups. If called inside a write
1678
 
        group on a repository that does not support refreshing in a write group
1679
 
        IsInWriteGroupError will be raised.
 
1633
        repository. It may not be called during a write group, but may be
 
1634
        called at any other time.
1680
1635
        """
 
1636
        if self.is_in_write_group():
 
1637
            raise errors.InternalBzrError(
 
1638
                "May not refresh_data while in a write group.")
1681
1639
        self._refresh_data()
1682
1640
 
1683
1641
    def resume_write_group(self, tokens):
1937
1895
                rev = self._serializer.read_revision_from_string(text)
1938
1896
                yield (revid, rev)
1939
1897
 
 
1898
    @needs_read_lock
 
1899
    def get_revision_xml(self, revision_id):
 
1900
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1901
        #       would have already do it.
 
1902
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1903
        # TODO: this can't just be replaced by:
 
1904
        # return self._serializer.write_revision_to_string(
 
1905
        #     self.get_revision(revision_id))
 
1906
        # as cStringIO preservers the encoding unlike write_revision_to_string
 
1907
        # or some other call down the path.
 
1908
        rev = self.get_revision(revision_id)
 
1909
        rev_tmp = cStringIO.StringIO()
 
1910
        # the current serializer..
 
1911
        self._serializer.write_revision(rev, rev_tmp)
 
1912
        rev_tmp.seek(0)
 
1913
        return rev_tmp.getvalue()
 
1914
 
1940
1915
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1941
1916
        """Produce a generator of revision deltas.
1942
1917
 
2455
2430
                result.revision_id, revision_id))
2456
2431
        return result
2457
2432
 
 
2433
    def _serialise_inventory(self, inv):
 
2434
        return self._serializer.write_inventory_to_string(inv)
 
2435
 
 
2436
    def _serialise_inventory_to_lines(self, inv):
 
2437
        return self._serializer.write_inventory_to_lines(inv)
 
2438
 
2458
2439
    def get_serializer_format(self):
2459
2440
        return self._serializer.format_num
2460
2441
 
2524
2505
            else:
2525
2506
                next_id = parents[0]
2526
2507
 
 
2508
    @needs_read_lock
 
2509
    def get_revision_inventory(self, revision_id):
 
2510
        """Return inventory of a past revision."""
 
2511
        # TODO: Unify this with get_inventory()
 
2512
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
2513
        # must be the same as its revision, so this is trivial.
 
2514
        if revision_id is None:
 
2515
            # This does not make sense: if there is no revision,
 
2516
            # then it is the current tree inventory surely ?!
 
2517
            # and thus get_root_id() is something that looks at the last
 
2518
            # commit on the branch, and the get_root_id is an inventory check.
 
2519
            raise NotImplementedError
 
2520
            # return Inventory(self.get_root_id())
 
2521
        else:
 
2522
            return self.get_inventory(revision_id)
 
2523
 
2527
2524
    def is_shared(self):
2528
2525
        """Return True if this repository is flagged as a shared repository."""
2529
2526
        raise NotImplementedError(self.is_shared)
2563
2560
            return RevisionTree(self, Inventory(root_id=None),
2564
2561
                                _mod_revision.NULL_REVISION)
2565
2562
        else:
2566
 
            inv = self.get_inventory(revision_id)
 
2563
            inv = self.get_revision_inventory(revision_id)
2567
2564
            return RevisionTree(self, inv, revision_id)
2568
2565
 
2569
2566
    def revision_trees(self, revision_ids):
2622
2619
            keys = tsort.topo_sort(parent_map)
2623
2620
        return [None] + list(keys)
2624
2621
 
2625
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2622
    def pack(self, hint=None):
2626
2623
        """Compress the data within the repository.
2627
2624
 
2628
2625
        This operation only makes sense for some repository types. For other
2638
2635
            obtained from the result of commit_write_group(). Out of
2639
2636
            date hints are simply ignored, because concurrent operations
2640
2637
            can obsolete them rapidly.
2641
 
 
2642
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2643
 
            the pack operation.
2644
2638
        """
2645
2639
 
2646
2640
    def get_transaction(self):
2671
2665
    def _make_parents_provider(self):
2672
2666
        return self
2673
2667
 
2674
 
    @needs_read_lock
2675
 
    def get_known_graph_ancestry(self, revision_ids):
2676
 
        """Return the known graph for a set of revision ids and their ancestors.
2677
 
        """
2678
 
        st = static_tuple.StaticTuple
2679
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
2680
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2681
 
        return graph.GraphThunkIdsToKeys(known_graph)
2682
 
 
2683
2668
    def get_graph(self, other_repository=None):
2684
2669
        """Return the graph walker for this repository format"""
2685
2670
        parents_provider = self._make_parents_provider()
3087
3072
    # Is the format experimental ?
3088
3073
    experimental = False
3089
3074
 
3090
 
    def __repr__(self):
3091
 
        return "%s()" % self.__class__.__name__
 
3075
    def __str__(self):
 
3076
        return "<%s>" % self.__class__.__name__
3092
3077
 
3093
3078
    def __eq__(self, other):
3094
3079
        # format objects are generally stateless
3212
3197
        """
3213
3198
        raise NotImplementedError(self.open)
3214
3199
 
3215
 
    def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3216
 
        from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3217
 
        hooks = BzrDir.hooks['post_repo_init']
3218
 
        if not hooks:
3219
 
            return
3220
 
        params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3221
 
        for hook in hooks:
3222
 
            hook(params)
3223
 
 
3224
3200
 
3225
3201
class MetaDirRepositoryFormat(RepositoryFormat):
3226
3202
    """Common base class for the new repositories using the metadir layout."""
3435
3411
        :return: None.
3436
3412
        """
3437
3413
        ui.ui_factory.warn_experimental_format_fetch(self)
3438
 
        from bzrlib.fetch import RepoFetcher
3439
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
3440
 
        if self.source._format.network_name() != self.target._format.network_name():
3441
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
3442
 
                from_format=self.source._format,
3443
 
                to_format=self.target._format)
3444
 
        f = RepoFetcher(to_repository=self.target,
 
3414
        f = _mod_fetch.RepoFetcher(to_repository=self.target,
3445
3415
                               from_repository=self.source,
3446
3416
                               last_revision=revision_id,
3447
3417
                               fetch_spec=fetch_spec,
4025
3995
        """See InterRepository.fetch()."""
4026
3996
        if fetch_spec is not None:
4027
3997
            raise AssertionError("Not implemented yet...")
 
3998
        # See <https://launchpad.net/bugs/456077> asking for a warning here
 
3999
        #
 
4000
        # nb this is only active for local-local fetches; other things using
 
4001
        # streaming.
 
4002
        ui.ui_factory.warn_cross_format_fetch(self.source._format,
 
4003
            self.target._format)
4028
4004
        ui.ui_factory.warn_experimental_format_fetch(self)
4029
4005
        if (not self.source.supports_rich_root()
4030
4006
            and self.target.supports_rich_root()):
4032
4008
            self._revision_id_to_root_id = {}
4033
4009
        else:
4034
4010
            self._converting_to_rich_root = False
4035
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
4036
 
        if self.source._format.network_name() != self.target._format.network_name():
4037
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
4038
 
                from_format=self.source._format,
4039
 
                to_format=self.target._format)
4040
4011
        revision_ids = self.target.search_missing_revision_ids(self.source,
4041
4012
            revision_id, find_ghosts=find_ghosts).get_keys()
4042
4013
        if not revision_ids:
4325
4296
                    self._extract_and_insert_inventories(
4326
4297
                        substream, src_serializer)
4327
4298
            elif substream_type == 'inventory-deltas':
 
4299
                ui.ui_factory.warn_cross_format_fetch(src_format,
 
4300
                    self.target_repo._format)
4328
4301
                self._extract_and_insert_inventory_deltas(
4329
4302
                    substream, src_serializer)
4330
4303
            elif substream_type == 'chk_bytes':