← 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
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,
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,
 
46
    ui,
47
47
    versionedfile,
48
48
    )
49
49
from bzrlib.bundle import serializer
52
52
from bzrlib.testament import Testament
53
53
""")
54
54
 
55
 
from bzrlib import (
56
 
    errors,
57
 
    registry,
58
 
    ui,
59
 
    )
60
55
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
61
56
from bzrlib.inter import InterObject
62
57
from bzrlib.inventory import (
65
60
    ROOT_ID,
66
61
    entry_factory,
67
62
    )
68
 
from bzrlib.recordcounter import RecordCounter
69
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
63
from bzrlib.lock import _RelockDebugMixin
 
64
from bzrlib import registry
70
65
from bzrlib.trace import (
71
66
    log_exception_quietly, note, mutter, mutter_callsite, warning)
72
67
 
75
70
_deprecation_warning_done = False
76
71
 
77
72
 
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
73
class CommitBuilder(object):
87
74
    """Provides an interface to build up a commit.
88
75
 
243
230
 
244
231
    def _gen_revision_id(self):
245
232
        """Return new revision-id."""
246
 
        return generate_ids.gen_revision_id(self._committer, self._timestamp)
 
233
        return generate_ids.gen_revision_id(self._config.username(),
 
234
                                            self._timestamp)
247
235
 
248
236
    def _generate_revision_if_needed(self):
249
237
        """Create a revision id if None was supplied.
289
277
 
290
278
        :param tree: The tree which is being committed.
291
279
        """
292
 
        if len(self.parents) == 0:
293
 
            raise errors.RootMissing()
 
280
        # NB: if there are no parents then this method is not called, so no
 
281
        # need to guard on parents having length.
294
282
        entry = entry_factory['directory'](tree.path2id(''), '',
295
283
            None)
296
284
        entry.revision = self._new_revision_id
871
859
        # versioned roots do not change unless the tree found a change.
872
860
 
873
861
 
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
862
######################################################################
892
863
# Repositories
893
864
 
894
865
 
895
 
class Repository(_RelockDebugMixin, controldir.ControlComponent):
 
866
class Repository(_RelockDebugMixin):
896
867
    """Repository holding history for one or more branches.
897
868
 
898
869
    The repository holds and retrieves historical information including
1046
1017
                " id and insertion revid (%r, %r)"
1047
1018
                % (inv.revision_id, revision_id))
1048
1019
        if inv.root is None:
1049
 
            raise errors.RootMissing()
 
1020
            raise AssertionError()
1050
1021
        return self._add_inventory_checked(revision_id, inv, parents)
1051
1022
 
1052
1023
    def _add_inventory_checked(self, revision_id, inv, parents):
1056
1027
 
1057
1028
        :seealso: add_inventory, for the contract.
1058
1029
        """
1059
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1030
        inv_lines = self._serialise_inventory_to_lines(inv)
1060
1031
        return self._inventory_add_lines(revision_id, parents,
1061
1032
            inv_lines, check_content=False)
1062
1033
 
1319
1290
 
1320
1291
        :param _format: The format of the repository on disk.
1321
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.
1322
1297
        """
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
1298
        super(Repository, self).__init__()
1327
1299
        self._format = _format
1328
1300
        # the following are part of the public API for Repository:
1343
1315
        # rather copying them?
1344
1316
        self._safe_to_return_from_cache = False
1345
1317
 
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
1318
    def __repr__(self):
1355
1319
        if self._fallback_repositories:
1356
1320
            return '%s(%r, fallback_repositories=%r)' % (
1404
1368
        data during reads, and allows a 'write_group' to be obtained. Write
1405
1369
        groups must be used for actual data insertion.
1406
1370
 
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
1371
        :param token: if this is already locked, then lock_write will fail
1414
1372
            unless the token matches the existing lock.
1415
1373
        :returns: a token if this instance supports tokens, otherwise None.
1418
1376
        :raises MismatchedToken: if the specified token doesn't match the token
1419
1377
            of the existing lock.
1420
1378
        :seealso: start_write_group.
1421
 
        :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
1422
1385
        """
1423
1386
        locked = self.is_locked()
1424
 
        token = self.control_files.lock_write(token=token)
 
1387
        result = self.control_files.lock_write(token=token)
1425
1388
        if not locked:
1426
1389
            self._warn_if_deprecated()
1427
1390
            self._note_lock('w')
1429
1392
                # Writes don't affect fallback repos
1430
1393
                repo.lock_read()
1431
1394
            self._refresh_data()
1432
 
        return RepositoryWriteLockResult(self.unlock, token)
 
1395
        return result
1433
1396
 
1434
1397
    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
1398
        locked = self.is_locked()
1441
1399
        self.control_files.lock_read()
1442
1400
        if not locked:
1445
1403
            for repo in self._fallback_repositories:
1446
1404
                repo.lock_read()
1447
1405
            self._refresh_data()
1448
 
        return LogicalLockResult(self.unlock)
1449
1406
 
1450
1407
    def get_physical_lock_status(self):
1451
1408
        return self.control_files.get_physical_lock_status()
1511
1468
 
1512
1469
        # now gather global repository information
1513
1470
        # XXX: This is available for many repos regardless of listability.
1514
 
        if self.user_transport.listable():
 
1471
        if self.bzrdir.root_transport.listable():
1515
1472
            # XXX: do we want to __define len__() ?
1516
1473
            # Maybe the versionedfiles object should provide a different
1517
1474
            # method to get the number of keys.
1527
1484
        :param using: If True, list only branches using this repository.
1528
1485
        """
1529
1486
        if using and not self.is_shared():
1530
 
            return self.bzrdir.list_branches()
 
1487
            try:
 
1488
                return [self.bzrdir.open_branch()]
 
1489
            except errors.NotBranchError:
 
1490
                return []
1531
1491
        class Evaluator(object):
1532
1492
 
1533
1493
            def __init__(self):
1542
1502
                    except errors.NoRepositoryPresent:
1543
1503
                        pass
1544
1504
                    else:
1545
 
                        return False, ([], repository)
 
1505
                        return False, (None, repository)
1546
1506
                self.first_call = False
1547
 
                value = (bzrdir.list_branches(), None)
 
1507
                try:
 
1508
                    value = (bzrdir.open_branch(), None)
 
1509
                except errors.NotBranchError:
 
1510
                    value = (None, None)
1548
1511
                return True, value
1549
1512
 
1550
 
        ret = []
1551
 
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1552
 
                self.user_transport, evaluate=Evaluator()):
1553
 
            if branches is not None:
1554
 
                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)
1555
1518
            if not using and repository is not None:
1556
 
                ret.extend(repository.find_branches())
1557
 
        return ret
 
1519
                branches.extend(repository.find_branches())
 
1520
        return branches
1558
1521
 
1559
1522
    @needs_read_lock
1560
1523
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1669
1632
        return missing_keys
1670
1633
 
1671
1634
    def refresh_data(self):
1672
 
        """Re-read any data needed to synchronise with disk.
 
1635
        """Re-read any data needed to to synchronise with disk.
1673
1636
 
1674
1637
        This method is intended to be called after another repository instance
1675
1638
        (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.
 
1639
        repository. It may not be called during a write group, but may be
 
1640
        called at any other time.
1681
1641
        """
 
1642
        if self.is_in_write_group():
 
1643
            raise errors.InternalBzrError(
 
1644
                "May not refresh_data while in a write group.")
1682
1645
        self._refresh_data()
1683
1646
 
1684
1647
    def resume_write_group(self, tokens):
1723
1686
                "May not fetch while in a write group.")
1724
1687
        # fast path same-url fetch operations
1725
1688
        # TODO: lift out to somewhere common with RemoteRepository
1726
 
        # <https://bugs.launchpad.net/bzr/+bug/401646>
 
1689
        # <https://bugs.edge.launchpad.net/bzr/+bug/401646>
1727
1690
        if (self.has_same_location(source)
1728
1691
            and fetch_spec is None
1729
1692
            and self._has_same_fallbacks(source)):
1938
1901
                rev = self._serializer.read_revision_from_string(text)
1939
1902
                yield (revid, rev)
1940
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
 
1941
1921
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1942
1922
        """Produce a generator of revision deltas.
1943
1923
 
2456
2436
                result.revision_id, revision_id))
2457
2437
        return result
2458
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
 
2459
2445
    def get_serializer_format(self):
2460
2446
        return self._serializer.format_num
2461
2447
 
2525
2511
            else:
2526
2512
                next_id = parents[0]
2527
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
 
2528
2530
    def is_shared(self):
2529
2531
        """Return True if this repository is flagged as a shared repository."""
2530
2532
        raise NotImplementedError(self.is_shared)
2564
2566
            return RevisionTree(self, Inventory(root_id=None),
2565
2567
                                _mod_revision.NULL_REVISION)
2566
2568
        else:
2567
 
            inv = self.get_inventory(revision_id)
 
2569
            inv = self.get_revision_inventory(revision_id)
2568
2570
            return RevisionTree(self, inv, revision_id)
2569
2571
 
2570
2572
    def revision_trees(self, revision_ids):
2623
2625
            keys = tsort.topo_sort(parent_map)
2624
2626
        return [None] + list(keys)
2625
2627
 
2626
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2628
    def pack(self, hint=None):
2627
2629
        """Compress the data within the repository.
2628
2630
 
2629
2631
        This operation only makes sense for some repository types. For other
2639
2641
            obtained from the result of commit_write_group(). Out of
2640
2642
            date hints are simply ignored, because concurrent operations
2641
2643
            can obsolete them rapidly.
2642
 
 
2643
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2644
 
            the pack operation.
2645
2644
        """
2646
2645
 
2647
2646
    def get_transaction(self):
2672
2671
    def _make_parents_provider(self):
2673
2672
        return self
2674
2673
 
2675
 
    @needs_read_lock
2676
 
    def get_known_graph_ancestry(self, revision_ids):
2677
 
        """Return the known graph for a set of revision ids and their ancestors.
2678
 
        """
2679
 
        st = static_tuple.StaticTuple
2680
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
2681
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2682
 
        return graph.GraphThunkIdsToKeys(known_graph)
2683
 
 
2684
2674
    def get_graph(self, other_repository=None):
2685
2675
        """Return the graph walker for this repository format"""
2686
2676
        parents_provider = self._make_parents_provider()
3088
3078
    # Is the format experimental ?
3089
3079
    experimental = False
3090
3080
 
3091
 
    def __repr__(self):
3092
 
        return "%s()" % self.__class__.__name__
 
3081
    def __str__(self):
 
3082
        return "<%s>" % self.__class__.__name__
3093
3083
 
3094
3084
    def __eq__(self, other):
3095
3085
        # format objects are generally stateless
3213
3203
        """
3214
3204
        raise NotImplementedError(self.open)
3215
3205
 
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
3206
 
3226
3207
class MetaDirRepositoryFormat(RepositoryFormat):
3227
3208
    """Common base class for the new repositories using the metadir layout."""
3436
3417
        :return: None.
3437
3418
        """
3438
3419
        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,
 
3420
        f = _mod_fetch.RepoFetcher(to_repository=self.target,
3446
3421
                               from_repository=self.source,
3447
3422
                               last_revision=revision_id,
3448
3423
                               fetch_spec=fetch_spec,
4026
4001
        """See InterRepository.fetch()."""
4027
4002
        if fetch_spec is not None:
4028
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)
4029
4010
        ui.ui_factory.warn_experimental_format_fetch(self)
4030
4011
        if (not self.source.supports_rich_root()
4031
4012
            and self.target.supports_rich_root()):
4033
4014
            self._revision_id_to_root_id = {}
4034
4015
        else:
4035
4016
            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
4017
        revision_ids = self.target.search_missing_revision_ids(self.source,
4042
4018
            revision_id, find_ghosts=find_ghosts).get_keys()
4043
4019
        if not revision_ids:
4284
4260
                is_resume = False
4285
4261
            try:
4286
4262
                # locked_insert_stream performs a commit|suspend.
4287
 
                return self._locked_insert_stream(stream, src_format,
4288
 
                    is_resume)
 
4263
                return self._locked_insert_stream(stream, src_format, is_resume)
4289
4264
            except:
4290
4265
                self.target_repo.abort_write_group(suppress_errors=True)
4291
4266
                raise
4327
4302
                    self._extract_and_insert_inventories(
4328
4303
                        substream, src_serializer)
4329
4304
            elif substream_type == 'inventory-deltas':
 
4305
                ui.ui_factory.warn_cross_format_fetch(src_format,
 
4306
                    self.target_repo._format)
4330
4307
                self._extract_and_insert_inventory_deltas(
4331
4308
                    substream, src_serializer)
4332
4309
            elif substream_type == 'chk_bytes':
4338
4315
                # required if the serializers are different only in terms of
4339
4316
                # the inventory.
4340
4317
                if src_serializer == to_serializer:
4341
 
                    self.target_repo.revisions.insert_record_stream(substream)
 
4318
                    self.target_repo.revisions.insert_record_stream(
 
4319
                        substream)
4342
4320
                else:
4343
4321
                    self._extract_and_insert_revisions(substream,
4344
4322
                        src_serializer)
4452
4430
        """Create a StreamSource streaming from from_repository."""
4453
4431
        self.from_repository = from_repository
4454
4432
        self.to_format = to_format
4455
 
        self._record_counter = RecordCounter()
4456
4433
 
4457
4434
    def delta_on_metadata(self):
4458
4435
        """Return True if delta's are permitted on metadata streams.