← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/knitrepo.py

(gz) Backslash escape selftest output when printing to non-unicode consoles
 (Martin [gz])

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/knitrepo.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2007-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
24
24
    lockdir,
25
25
    osutils,
26
26
    revision as _mod_revision,
 
27
    trace,
27
28
    transactions,
28
29
    versionedfile,
29
30
    xml5,
31
32
    xml7,
32
33
    )
33
34
""")
34
 
from bzrlib import (
35
 
    symbol_versioning,
36
 
    )
37
35
from bzrlib.decorators import needs_read_lock, needs_write_lock
38
36
from bzrlib.repository import (
39
37
    CommitBuilder,
 
38
    InterRepository,
 
39
    InterSameDataRepository,
 
40
    IsInWriteGroupError,
40
41
    MetaDirRepository,
41
42
    MetaDirRepositoryFormat,
42
43
    RepositoryFormat,
43
44
    RootCommitBuilder,
44
45
    )
45
 
from bzrlib.trace import mutter, mutter_callsite
46
46
 
47
47
 
48
48
class _KnitParentsProvider(object):
210
210
    def _refresh_data(self):
211
211
        if not self.is_locked():
212
212
            return
 
213
        if self.is_in_write_group():
 
214
            raise IsInWriteGroupError(self)
213
215
        # Create a new transaction to force all knits to see the scope change.
214
216
        # This is safe because we're outside a write group.
215
217
        self.control_files._finish_transaction()
342
344
        :param shared: If true the repository will be initialized as a shared
343
345
                       repository.
344
346
        """
345
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
347
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
346
348
        dirs = ['knits']
347
349
        files = []
348
350
        utf8_files = [('format', self.get_format_string())]
360
362
        result.revisions.get_parent_map([('A',)])
361
363
        result.signatures.get_parent_map([('A',)])
362
364
        result.unlock()
 
365
        self._run_post_repo_init_hooks(result, a_bzrdir, shared)
363
366
        return result
364
367
 
365
368
    def open(self, a_bzrdir, _found=False, _override_transport=None):
444
447
    repository_class = KnitRepository
445
448
    _commit_builder_class = RootCommitBuilder
446
449
    rich_root_data = True
 
450
    experimental = True
447
451
    supports_tree_reference = True
448
452
    @property
449
453
    def _serializer(self):
505
509
    def get_format_description(self):
506
510
        """See RepositoryFormat.get_format_description()."""
507
511
        return "Knit repository format 4"
 
512
 
 
513
 
 
514
class InterKnitRepo(InterSameDataRepository):
 
515
    """Optimised code paths between Knit based repositories."""
 
516
 
 
517
    @classmethod
 
518
    def _get_repo_format_to_test(self):
 
519
        return RepositoryFormatKnit1()
 
520
 
 
521
    @staticmethod
 
522
    def is_compatible(source, target):
 
523
        """Be compatible with known Knit formats.
 
524
 
 
525
        We don't test for the stores being of specific types because that
 
526
        could lead to confusing results, and there is no need to be
 
527
        overly general.
 
528
        """
 
529
        try:
 
530
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
 
531
                isinstance(target._format, RepositoryFormatKnit))
 
532
        except AttributeError:
 
533
            return False
 
534
        return are_knits and InterRepository._same_model(source, target)
 
535
 
 
536
    @needs_read_lock
 
537
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
538
        """See InterRepository.missing_revision_ids()."""
 
539
        if revision_id is not None:
 
540
            source_ids = self.source.get_ancestry(revision_id)
 
541
            if source_ids[0] is not None:
 
542
                raise AssertionError()
 
543
            source_ids.pop(0)
 
544
        else:
 
545
            source_ids = self.source.all_revision_ids()
 
546
        source_ids_set = set(source_ids)
 
547
        # source_ids is the worst possible case we may need to pull.
 
548
        # now we want to filter source_ids against what we actually
 
549
        # have in target, but don't try to check for existence where we know
 
550
        # we do not have a revision as that would be pointless.
 
551
        target_ids = set(self.target.all_revision_ids())
 
552
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
553
        actually_present_revisions = set(
 
554
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
555
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
556
        if revision_id is not None:
 
557
            # we used get_ancestry to determine source_ids then we are assured all
 
558
            # revisions referenced are present as they are installed in topological order.
 
559
            # and the tip revision was validated by get_ancestry.
 
560
            result_set = required_revisions
 
561
        else:
 
562
            # if we just grabbed the possibly available ids, then
 
563
            # we only have an estimate of whats available and need to validate
 
564
            # that against the revision records.
 
565
            result_set = set(
 
566
                self.source._eliminate_revisions_not_present(required_revisions))
 
567
        return self.source.revision_ids_to_search_result(result_set)
 
568
 
 
569
 
 
570
InterRepository.register_optimiser(InterKnitRepo)