← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Martin Pool
  • Date: 2010-06-02 05:03:31 UTC
  • mto: This revision was merged to the branch mainline in revision 5279.
  • Revision ID: mbp@canonical.com-20100602050331-n2p1qt8hfsahspnv
Correct more sloppy use of the term 'Linux'

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,
30
29
    fetch as _mod_fetch,
31
30
    fifo_cache,
243
242
 
244
243
    def _gen_revision_id(self):
245
244
        """Return new revision-id."""
246
 
        return generate_ids.gen_revision_id(self._committer, self._timestamp)
 
245
        return generate_ids.gen_revision_id(self._config.username(),
 
246
                                            self._timestamp)
247
247
 
248
248
    def _generate_revision_if_needed(self):
249
249
        """Create a revision id if None was supplied.
434
434
            else:
435
435
                # we don't need to commit this, because the caller already
436
436
                # determined that an existing revision of this file is
437
 
                # appropriate. If it's not being considered for committing then
 
437
                # appropriate. If its not being considered for committing then
438
438
                # it and all its parents to the root must be unaltered so
439
439
                # no-change against the basis.
440
440
                if ie.revision == self._new_revision_id:
756
756
                    # after iter_changes examines and decides it has changed,
757
757
                    # we will unconditionally record a new version even if some
758
758
                    # other process reverts it while commit is running (with
759
 
                    # the revert happening after iter_changes did its
 
759
                    # the revert happening after iter_changes did it's
760
760
                    # examination).
761
761
                    if change[7][1]:
762
762
                        entry.executable = True
892
892
# Repositories
893
893
 
894
894
 
895
 
class Repository(_RelockDebugMixin, controldir.ControlComponent):
 
895
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
896
896
    """Repository holding history for one or more branches.
897
897
 
898
898
    The repository holds and retrieves historical information including
945
945
        pointing to .bzr/repository.
946
946
    """
947
947
 
948
 
    # What class to use for a CommitBuilder. Often it's simpler to change this
 
948
    # What class to use for a CommitBuilder. Often its simpler to change this
949
949
    # in a Repository class subclass rather than to override
950
950
    # get_commit_builder.
951
951
    _commit_builder_class = CommitBuilder
2511
2511
            ancestors will be traversed.
2512
2512
        """
2513
2513
        graph = self.get_graph()
2514
 
        stop_revisions = (None, _mod_revision.NULL_REVISION)
2515
 
        return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
 
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]
2516
2527
 
2517
2528
    def is_shared(self):
2518
2529
        """Return True if this repository is flagged as a shared repository."""
2619
2630
        types it should be a no-op that just returns.
2620
2631
 
2621
2632
        This stub method does not require a lock, but subclasses should use
2622
 
        @needs_write_lock as this is a long running call it's reasonable to
 
2633
        @needs_write_lock as this is a long running call its reasonable to
2623
2634
        implicitly lock for the user.
2624
2635
 
2625
2636
        :param hint: If not supplied, the whole repository is packed.
3378
3389
    'bzrlib.repofmt.groupcompress_repo',
3379
3390
    'RepositoryFormat2a',
3380
3391
    )
3381
 
format_registry.register_lazy(
3382
 
    'Bazaar development format 8\n',
3383
 
    'bzrlib.repofmt.groupcompress_repo',
3384
 
    'RepositoryFormat2aSubtree',
3385
 
    )
3386
3392
 
3387
3393
 
3388
3394
class InterRepository(InterObject):
3842
3848
                basis_id, delta, current_revision_id, parents_parents)
3843
3849
            cache[current_revision_id] = parent_tree
3844
3850
 
3845
 
    def _fetch_batch(self, revision_ids, basis_id, cache):
 
3851
    def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
3846
3852
        """Fetch across a few revisions.
3847
3853
 
3848
3854
        :param revision_ids: The revisions to copy
3849
3855
        :param basis_id: The revision_id of a tree that must be in cache, used
3850
3856
            as a basis for delta when no other base is available
3851
3857
        :param cache: A cache of RevisionTrees that we can use.
 
3858
        :param a_graph: A Graph object to determine the heads() of the
 
3859
            rich-root data stream.
3852
3860
        :return: The revision_id of the last converted tree. The RevisionTree
3853
3861
            for it will be in cache
3854
3862
        """
3922
3930
        if root_keys_to_create:
3923
3931
            root_stream = _mod_fetch._new_root_data_stream(
3924
3932
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3925
 
                self.source)
 
3933
                self.source, graph=a_graph)
3926
3934
            to_texts.insert_record_stream(root_stream)
3927
3935
        to_texts.insert_record_stream(from_texts.get_record_stream(
3928
3936
            text_keys, self.target._format._fetch_order,
3985
3993
        cache[basis_id] = basis_tree
3986
3994
        del basis_tree # We don't want to hang on to it here
3987
3995
        hints = []
3988
 
        a_graph = None
 
3996
        if self._converting_to_rich_root and len(revision_ids) > 100:
 
3997
            a_graph = _mod_fetch._get_rich_root_heads_graph(self.source,
 
3998
                                                            revision_ids)
 
3999
        else:
 
4000
            a_graph = None
3989
4001
 
3990
4002
        for offset in range(0, len(revision_ids), batch_size):
3991
4003
            self.target.start_write_group()
3993
4005
                pb.update('Transferring revisions', offset,
3994
4006
                          len(revision_ids))
3995
4007
                batch = revision_ids[offset:offset+batch_size]
3996
 
                basis_id = self._fetch_batch(batch, basis_id, cache)
 
4008
                basis_id = self._fetch_batch(batch, basis_id, cache,
 
4009
                                             a_graph=a_graph)
3997
4010
            except:
3998
4011
                self.source._safe_to_return_from_cache = False
3999
4012
                self.target.abort_write_group()
4065
4078
            basis_id = first_rev.parent_ids[0]
4066
4079
            # only valid as a basis if the target has it
4067
4080
            self.target.get_revision(basis_id)
4068
 
            # Try to get a basis tree - if it's a ghost it will hit the
 
4081
            # Try to get a basis tree - if its a ghost it will hit the
4069
4082
            # NoSuchRevision case.
4070
4083
            basis_tree = self.source.revision_tree(basis_id)
4071
4084
        except (IndexError, errors.NoSuchRevision):