← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Jelmer Vernooij
  • Date: 2010-03-21 21:39:33 UTC
  • mfrom: (5102 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5143.
  • Revision ID: jelmer@samba.org-20100321213933-fexeh9zcoz8oaju2
merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
25
25
    check,
26
26
    chk_map,
27
27
    config,
28
 
    controldir,
29
28
    debug,
 
29
    errors,
30
30
    fetch as _mod_fetch,
31
31
    fifo_cache,
32
32
    generate_ids,
44
44
    symbol_versioning,
45
45
    trace,
46
46
    tsort,
 
47
    ui,
47
48
    versionedfile,
48
49
    )
49
50
from bzrlib.bundle import serializer
52
53
from bzrlib.testament import Testament
53
54
""")
54
55
 
55
 
from bzrlib import (
56
 
    errors,
57
 
    registry,
58
 
    ui,
59
 
    )
60
56
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
61
57
from bzrlib.inter import InterObject
62
58
from bzrlib.inventory import (
65
61
    ROOT_ID,
66
62
    entry_factory,
67
63
    )
68
 
from bzrlib.recordcounter import RecordCounter
69
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
64
from bzrlib.lock import _RelockDebugMixin
 
65
from bzrlib import registry
70
66
from bzrlib.trace import (
71
67
    log_exception_quietly, note, mutter, mutter_callsite, warning)
72
68
 
75
71
_deprecation_warning_done = False
76
72
 
77
73
 
78
 
class IsInWriteGroupError(errors.InternalBzrError):
79
 
 
80
 
    _fmt = "May not refresh_data of repo %(repo)s while in a write group."
81
 
 
82
 
    def __init__(self, repo):
83
 
        errors.InternalBzrError.__init__(self, repo=repo)
84
 
 
85
 
 
86
74
class CommitBuilder(object):
87
75
    """Provides an interface to build up a commit.
88
76
 
243
231
 
244
232
    def _gen_revision_id(self):
245
233
        """Return new revision-id."""
246
 
        return generate_ids.gen_revision_id(self._committer, self._timestamp)
 
234
        return generate_ids.gen_revision_id(self._config.username(),
 
235
                                            self._timestamp)
247
236
 
248
237
    def _generate_revision_if_needed(self):
249
238
        """Create a revision id if None was supplied.
289
278
 
290
279
        :param tree: The tree which is being committed.
291
280
        """
292
 
        if len(self.parents) == 0:
293
 
            raise errors.RootMissing()
 
281
        # NB: if there are no parents then this method is not called, so no
 
282
        # need to guard on parents having length.
294
283
        entry = entry_factory['directory'](tree.path2id(''), '',
295
284
            None)
296
285
        entry.revision = self._new_revision_id
871
860
        # versioned roots do not change unless the tree found a change.
872
861
 
873
862
 
874
 
class RepositoryWriteLockResult(LogicalLockResult):
875
 
    """The result of write locking a repository.
876
 
 
877
 
    :ivar repository_token: The token obtained from the underlying lock, or
878
 
        None.
879
 
    :ivar unlock: A callable which will unlock the lock.
880
 
    """
881
 
 
882
 
    def __init__(self, unlock, repository_token):
883
 
        LogicalLockResult.__init__(self, unlock)
884
 
        self.repository_token = repository_token
885
 
 
886
 
    def __repr__(self):
887
 
        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
888
 
            self.unlock)
889
 
 
890
 
 
891
863
######################################################################
892
864
# Repositories
893
865
 
894
866
 
895
 
class Repository(_RelockDebugMixin, controldir.ControlComponent):
 
867
class Repository(_RelockDebugMixin):
896
868
    """Repository holding history for one or more branches.
897
869
 
898
870
    The repository holds and retrieves historical information including
1046
1018
                " id and insertion revid (%r, %r)"
1047
1019
                % (inv.revision_id, revision_id))
1048
1020
        if inv.root is None:
1049
 
            raise errors.RootMissing()
 
1021
            raise AssertionError()
1050
1022
        return self._add_inventory_checked(revision_id, inv, parents)
1051
1023
 
1052
1024
    def _add_inventory_checked(self, revision_id, inv, parents):
1319
1291
 
1320
1292
        :param _format: The format of the repository on disk.
1321
1293
        :param a_bzrdir: The BzrDir of the repository.
 
1294
 
 
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.
1322
1298
        """
1323
 
        # In the future we will have a single api for all stores for
1324
 
        # getting file texts, inventories and revisions, then
1325
 
        # this construct will accept instances of those things.
1326
1299
        super(Repository, self).__init__()
1327
1300
        self._format = _format
1328
1301
        # the following are part of the public API for Repository:
1343
1316
        # rather copying them?
1344
1317
        self._safe_to_return_from_cache = False
1345
1318
 
1346
 
    @property
1347
 
    def user_transport(self):
1348
 
        return self.bzrdir.user_transport
1349
 
 
1350
 
    @property
1351
 
    def control_transport(self):
1352
 
        return self._transport
1353
 
 
1354
1319
    def __repr__(self):
1355
1320
        if self._fallback_repositories:
1356
1321
            return '%s(%r, fallback_repositories=%r)' % (
1404
1369
        data during reads, and allows a 'write_group' to be obtained. Write
1405
1370
        groups must be used for actual data insertion.
1406
1371
 
1407
 
        A token should be passed in if you know that you have locked the object
1408
 
        some other way, and need to synchronise this object's state with that
1409
 
        fact.
1410
 
 
1411
 
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1412
 
 
1413
1372
        :param token: if this is already locked, then lock_write will fail
1414
1373
            unless the token matches the existing lock.
1415
1374
        :returns: a token if this instance supports tokens, otherwise None.
1418
1377
        :raises MismatchedToken: if the specified token doesn't match the token
1419
1378
            of the existing lock.
1420
1379
        :seealso: start_write_group.
1421
 
        :return: A RepositoryWriteLockResult.
 
1380
 
 
1381
        A token should be passed in if you know that you have locked the object
 
1382
        some other way, and need to synchronise this object's state with that
 
1383
        fact.
 
1384
 
 
1385
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1422
1386
        """
1423
1387
        locked = self.is_locked()
1424
 
        token = self.control_files.lock_write(token=token)
 
1388
        result = self.control_files.lock_write(token=token)
1425
1389
        if not locked:
1426
1390
            self._warn_if_deprecated()
1427
1391
            self._note_lock('w')
1429
1393
                # Writes don't affect fallback repos
1430
1394
                repo.lock_read()
1431
1395
            self._refresh_data()
1432
 
        return RepositoryWriteLockResult(self.unlock, token)
 
1396
        return result
1433
1397
 
1434
1398
    def lock_read(self):
1435
 
        """Lock the repository for read operations.
1436
 
 
1437
 
        :return: An object with an unlock method which will release the lock
1438
 
            obtained.
1439
 
        """
1440
1399
        locked = self.is_locked()
1441
1400
        self.control_files.lock_read()
1442
1401
        if not locked:
1445
1404
            for repo in self._fallback_repositories:
1446
1405
                repo.lock_read()
1447
1406
            self._refresh_data()
1448
 
        return LogicalLockResult(self.unlock)
1449
1407
 
1450
1408
    def get_physical_lock_status(self):
1451
1409
        return self.control_files.get_physical_lock_status()
1511
1469
 
1512
1470
        # now gather global repository information
1513
1471
        # XXX: This is available for many repos regardless of listability.
1514
 
        if self.user_transport.listable():
 
1472
        if self.bzrdir.root_transport.listable():
1515
1473
            # XXX: do we want to __define len__() ?
1516
1474
            # Maybe the versionedfiles object should provide a different
1517
1475
            # method to get the number of keys.
1549
1507
 
1550
1508
        ret = []
1551
1509
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1552
 
                self.user_transport, evaluate=Evaluator()):
 
1510
                self.bzrdir.root_transport, evaluate=Evaluator()):
1553
1511
            if branches is not None:
1554
1512
                ret.extend(branches)
1555
1513
            if not using and repository is not None:
1669
1627
        return missing_keys
1670
1628
 
1671
1629
    def refresh_data(self):
1672
 
        """Re-read any data needed to synchronise with disk.
 
1630
        """Re-read any data needed to to synchronise with disk.
1673
1631
 
1674
1632
        This method is intended to be called after another repository instance
1675
1633
        (such as one used by a smart server) has inserted data into the
1676
 
        repository. On all repositories this will work outside of write groups.
1677
 
        Some repository formats (pack and newer for bzrlib native formats)
1678
 
        support refresh_data inside write groups. If called inside a write
1679
 
        group on a repository that does not support refreshing in a write group
1680
 
        IsInWriteGroupError will be raised.
 
1634
        repository. It may not be called during a write group, but may be
 
1635
        called at any other time.
1681
1636
        """
 
1637
        if self.is_in_write_group():
 
1638
            raise errors.InternalBzrError(
 
1639
                "May not refresh_data while in a write group.")
1682
1640
        self._refresh_data()
1683
1641
 
1684
1642
    def resume_write_group(self, tokens):
1723
1681
                "May not fetch while in a write group.")
1724
1682
        # fast path same-url fetch operations
1725
1683
        # TODO: lift out to somewhere common with RemoteRepository
1726
 
        # <https://bugs.launchpad.net/bzr/+bug/401646>
 
1684
        # <https://bugs.edge.launchpad.net/bzr/+bug/401646>
1727
1685
        if (self.has_same_location(source)
1728
1686
            and fetch_spec is None
1729
1687
            and self._has_same_fallbacks(source)):
2623
2581
            keys = tsort.topo_sort(parent_map)
2624
2582
        return [None] + list(keys)
2625
2583
 
2626
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2584
    def pack(self, hint=None):
2627
2585
        """Compress the data within the repository.
2628
2586
 
2629
2587
        This operation only makes sense for some repository types. For other
2639
2597
            obtained from the result of commit_write_group(). Out of
2640
2598
            date hints are simply ignored, because concurrent operations
2641
2599
            can obsolete them rapidly.
2642
 
 
2643
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2644
 
            the pack operation.
2645
2600
        """
2646
2601
 
2647
2602
    def get_transaction(self):
3088
3043
    # Is the format experimental ?
3089
3044
    experimental = False
3090
3045
 
3091
 
    def __repr__(self):
3092
 
        return "%s()" % self.__class__.__name__
 
3046
    def __str__(self):
 
3047
        return "<%s>" % self.__class__.__name__
3093
3048
 
3094
3049
    def __eq__(self, other):
3095
3050
        # format objects are generally stateless
3213
3168
        """
3214
3169
        raise NotImplementedError(self.open)
3215
3170
 
3216
 
    def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3217
 
        from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3218
 
        hooks = BzrDir.hooks['post_repo_init']
3219
 
        if not hooks:
3220
 
            return
3221
 
        params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3222
 
        for hook in hooks:
3223
 
            hook(params)
3224
 
 
3225
3171
 
3226
3172
class MetaDirRepositoryFormat(RepositoryFormat):
3227
3173
    """Common base class for the new repositories using the metadir layout."""
3436
3382
        :return: None.
3437
3383
        """
3438
3384
        ui.ui_factory.warn_experimental_format_fetch(self)
3439
 
        from bzrlib.fetch import RepoFetcher
3440
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
3441
 
        if self.source._format.network_name() != self.target._format.network_name():
3442
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
3443
 
                from_format=self.source._format,
3444
 
                to_format=self.target._format)
3445
 
        f = RepoFetcher(to_repository=self.target,
 
3385
        f = _mod_fetch.RepoFetcher(to_repository=self.target,
3446
3386
                               from_repository=self.source,
3447
3387
                               last_revision=revision_id,
3448
3388
                               fetch_spec=fetch_spec,
4026
3966
        """See InterRepository.fetch()."""
4027
3967
        if fetch_spec is not None:
4028
3968
            raise AssertionError("Not implemented yet...")
 
3969
        # See <https://launchpad.net/bugs/456077> asking for a warning here
 
3970
        #
 
3971
        # nb this is only active for local-local fetches; other things using
 
3972
        # streaming.
 
3973
        ui.ui_factory.warn_cross_format_fetch(self.source._format,
 
3974
            self.target._format)
4029
3975
        ui.ui_factory.warn_experimental_format_fetch(self)
4030
3976
        if (not self.source.supports_rich_root()
4031
3977
            and self.target.supports_rich_root()):
4033
3979
            self._revision_id_to_root_id = {}
4034
3980
        else:
4035
3981
            self._converting_to_rich_root = False
4036
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
4037
 
        if self.source._format.network_name() != self.target._format.network_name():
4038
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
4039
 
                from_format=self.source._format,
4040
 
                to_format=self.target._format)
4041
3982
        revision_ids = self.target.search_missing_revision_ids(self.source,
4042
3983
            revision_id, find_ghosts=find_ghosts).get_keys()
4043
3984
        if not revision_ids:
4284
4225
                is_resume = False
4285
4226
            try:
4286
4227
                # locked_insert_stream performs a commit|suspend.
4287
 
                return self._locked_insert_stream(stream, src_format,
4288
 
                    is_resume)
 
4228
                return self._locked_insert_stream(stream, src_format, is_resume)
4289
4229
            except:
4290
4230
                self.target_repo.abort_write_group(suppress_errors=True)
4291
4231
                raise
4327
4267
                    self._extract_and_insert_inventories(
4328
4268
                        substream, src_serializer)
4329
4269
            elif substream_type == 'inventory-deltas':
 
4270
                ui.ui_factory.warn_cross_format_fetch(src_format,
 
4271
                    self.target_repo._format)
4330
4272
                self._extract_and_insert_inventory_deltas(
4331
4273
                    substream, src_serializer)
4332
4274
            elif substream_type == 'chk_bytes':
4338
4280
                # required if the serializers are different only in terms of
4339
4281
                # the inventory.
4340
4282
                if src_serializer == to_serializer:
4341
 
                    self.target_repo.revisions.insert_record_stream(substream)
 
4283
                    self.target_repo.revisions.insert_record_stream(
 
4284
                        substream)
4342
4285
                else:
4343
4286
                    self._extract_and_insert_revisions(substream,
4344
4287
                        src_serializer)
4452
4395
        """Create a StreamSource streaming from from_repository."""
4453
4396
        self.from_repository = from_repository
4454
4397
        self.to_format = to_format
4455
 
        self._record_counter = RecordCounter()
4456
4398
 
4457
4399
    def delta_on_metadata(self):
4458
4400
        """Return True if delta's are permitted on metadata streams.