← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

Merge bzr.dev to resolve news conflict

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
39
39
    lockdir,
40
40
    lru_cache,
41
41
    osutils,
 
42
    pyutils,
42
43
    revision as _mod_revision,
43
44
    static_tuple,
44
45
    symbol_versioning,
52
53
from bzrlib.testament import Testament
53
54
""")
54
55
 
 
56
import sys
55
57
from bzrlib import (
56
58
    errors,
57
59
    registry,
113
115
 
114
116
        if committer is None:
115
117
            self._committer = self._config.username()
 
118
        elif not isinstance(committer, unicode):
 
119
            self._committer = committer.decode() # throw if non-ascii
116
120
        else:
117
121
            self._committer = committer
118
122
 
434
438
            else:
435
439
                # we don't need to commit this, because the caller already
436
440
                # determined that an existing revision of this file is
437
 
                # appropriate. If its not being considered for committing then
 
441
                # appropriate. If it's not being considered for committing then
438
442
                # it and all its parents to the root must be unaltered so
439
443
                # no-change against the basis.
440
444
                if ie.revision == self._new_revision_id:
756
760
                    # after iter_changes examines and decides it has changed,
757
761
                    # we will unconditionally record a new version even if some
758
762
                    # other process reverts it while commit is running (with
759
 
                    # the revert happening after iter_changes did it's
 
763
                    # the revert happening after iter_changes did its
760
764
                    # examination).
761
765
                    if change[7][1]:
762
766
                        entry.executable = True
945
949
        pointing to .bzr/repository.
946
950
    """
947
951
 
948
 
    # What class to use for a CommitBuilder. Often its simpler to change this
 
952
    # What class to use for a CommitBuilder. Often it's simpler to change this
949
953
    # in a Repository class subclass rather than to override
950
954
    # get_commit_builder.
951
955
    _commit_builder_class = CommitBuilder
2511
2515
            ancestors will be traversed.
2512
2516
        """
2513
2517
        graph = self.get_graph()
2514
 
        next_id = revision_id
2515
 
        while True:
2516
 
            if next_id in (None, _mod_revision.NULL_REVISION):
2517
 
                return
2518
 
            try:
2519
 
                parents = graph.get_parent_map([next_id])[next_id]
2520
 
            except KeyError:
2521
 
                raise errors.RevisionNotPresent(next_id, self)
2522
 
            yield next_id
2523
 
            if len(parents) == 0:
2524
 
                return
2525
 
            else:
2526
 
                next_id = parents[0]
 
2518
        stop_revisions = (None, _mod_revision.NULL_REVISION)
 
2519
        return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
2527
2520
 
2528
2521
    def is_shared(self):
2529
2522
        """Return True if this repository is flagged as a shared repository."""
2630
2623
        types it should be a no-op that just returns.
2631
2624
 
2632
2625
        This stub method does not require a lock, but subclasses should use
2633
 
        @needs_write_lock as this is a long running call its reasonable to
 
2626
        @needs_write_lock as this is a long running call it's reasonable to
2634
2627
        implicitly lock for the user.
2635
2628
 
2636
2629
        :param hint: If not supplied, the whole repository is packed.
2836
2829
            % (name, from_module),
2837
2830
            DeprecationWarning,
2838
2831
            stacklevel=2)
2839
 
        m = __import__(from_module, globals(), locals(), [name])
2840
2832
        try:
2841
 
            return getattr(m, name)
 
2833
            return pyutils.get_named_object(from_module, name)
2842
2834
        except AttributeError:
2843
2835
            raise AttributeError('module %s has no name %s'
2844
 
                    % (m, name))
 
2836
                    % (sys.modules[from_module], name))
2845
2837
    globals()[name] = _deprecated_repository_forwarder
2846
2838
 
2847
2839
for _name in [
3853
3845
                basis_id, delta, current_revision_id, parents_parents)
3854
3846
            cache[current_revision_id] = parent_tree
3855
3847
 
3856
 
    def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
 
3848
    def _fetch_batch(self, revision_ids, basis_id, cache):
3857
3849
        """Fetch across a few revisions.
3858
3850
 
3859
3851
        :param revision_ids: The revisions to copy
3860
3852
        :param basis_id: The revision_id of a tree that must be in cache, used
3861
3853
            as a basis for delta when no other base is available
3862
3854
        :param cache: A cache of RevisionTrees that we can use.
3863
 
        :param a_graph: A Graph object to determine the heads() of the
3864
 
            rich-root data stream.
3865
3855
        :return: The revision_id of the last converted tree. The RevisionTree
3866
3856
            for it will be in cache
3867
3857
        """
3935
3925
        if root_keys_to_create:
3936
3926
            root_stream = _mod_fetch._new_root_data_stream(
3937
3927
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3938
 
                self.source, graph=a_graph)
 
3928
                self.source)
3939
3929
            to_texts.insert_record_stream(root_stream)
3940
3930
        to_texts.insert_record_stream(from_texts.get_record_stream(
3941
3931
            text_keys, self.target._format._fetch_order,
3998
3988
        cache[basis_id] = basis_tree
3999
3989
        del basis_tree # We don't want to hang on to it here
4000
3990
        hints = []
4001
 
        if self._converting_to_rich_root and len(revision_ids) > 100:
4002
 
            a_graph = _mod_fetch._get_rich_root_heads_graph(self.source,
4003
 
                                                            revision_ids)
4004
 
        else:
4005
 
            a_graph = None
 
3991
        a_graph = None
4006
3992
 
4007
3993
        for offset in range(0, len(revision_ids), batch_size):
4008
3994
            self.target.start_write_group()
4010
3996
                pb.update('Transferring revisions', offset,
4011
3997
                          len(revision_ids))
4012
3998
                batch = revision_ids[offset:offset+batch_size]
4013
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
4014
 
                                             a_graph=a_graph)
 
3999
                basis_id = self._fetch_batch(batch, basis_id, cache)
4015
4000
            except:
4016
4001
                self.source._safe_to_return_from_cache = False
4017
4002
                self.target.abort_write_group()
4083
4068
            basis_id = first_rev.parent_ids[0]
4084
4069
            # only valid as a basis if the target has it
4085
4070
            self.target.get_revision(basis_id)
4086
 
            # Try to get a basis tree - if its a ghost it will hit the
 
4071
            # Try to get a basis tree - if it's a ghost it will hit the
4087
4072
            # NoSuchRevision case.
4088
4073
            basis_tree = self.source.revision_tree(basis_id)
4089
4074
        except (IndexError, errors.NoSuchRevision):