← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Aaron Bentley
  • Date: 2008-06-19 15:22:42 UTC
  • mto: This revision was merged to the branch mainline in revision 3538.
  • Revision ID: aaron@aaronbentley.com-20080619152242-v8pasad243zg5lyd
Defer handling relative stacking URLs as late as possible.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
371
371
        bzrdir._find_or_create_repository(force_new_repo)
372
372
        return bzrdir.create_branch()
373
373
 
374
 
    def determine_repository_policy(self, force_new_repo=False, stack_on=None):
 
374
    def determine_repository_policy(self, force_new_repo=False, stack_on=None,
 
375
                                    stack_on_pwd=None):
375
376
        """Return an object representing a policy to use.
376
377
 
377
378
        This controls whether a new repository is created, or a shared
379
380
        """
380
381
        def repository_policy(found_bzrdir):
381
382
            stack_on = None
 
383
            stack_on_pwd = None
382
384
            config = found_bzrdir.get_config()
383
385
            stop = False
384
386
            if config is not None:
385
387
                stack_on = config.get_default_stack_on()
386
388
                if stack_on is not None:
387
 
                    stack_on = urlutils.rebase_url(stack_on,
388
 
                        found_bzrdir.root_transport.base,
389
 
                        self.root_transport.base)
 
389
                    stack_on_pwd = found_bzrdir.root_transport.base
390
390
                    stop = True
391
391
            # does it have a repository ?
392
392
            try:
402
402
            if not stop:
403
403
                return None, False
404
404
            if repository:
405
 
                return UseExistingRepository(repository, stack_on), True
 
405
                return UseExistingRepository(repository, stack_on,
 
406
                                             stack_on_pwd), True
406
407
            else:
407
 
                return CreateRepository(self, stack_on), True
 
408
                return CreateRepository(self, stack_on, stack_on_pwd), True
408
409
 
409
410
        if not force_new_repo:
410
411
            if stack_on is None:
414
415
            else:
415
416
                try:
416
417
                    return UseExistingRepository(self.open_repository(),
417
 
                                                 stack_on)
 
418
                                                 stack_on, stack_on_pwd)
418
419
                except errors.NoRepositoryPresent:
419
420
                    pass
420
 
        return CreateRepository(self, stack_on)
 
421
        return CreateRepository(self, stack_on, stack_on_pwd)
421
422
 
422
423
    def _find_or_create_repository(self, force_new_repo):
423
424
        """Create a new repository if needed, returning the repository."""
1033
1034
            except errors.NoRepositoryPresent:
1034
1035
                source_repository = None
1035
1036
            stacked_branch_url = None
1036
 
        repository_policy = result.determine_repository_policy(force_new_repo)
 
1037
        repository_policy = result.determine_repository_policy(
 
1038
            force_new_repo, stacked_branch_url)
1037
1039
        result_repo = repository_policy.acquire_repository()
1038
 
        if stacked_branch_url is not None:
1039
 
            stacked_dir = BzrDir.open(stacked_branch_url)
1040
 
            try:
1041
 
                stacked_repo = stacked_dir.open_branch().repository
1042
 
            except errors.NotBranchError:
1043
 
                stacked_repo = stacked_dir.open_repository()
1044
 
            result_repo.add_fallback_repository(stacked_repo)
 
1040
        if source_repository is not None:
1045
1041
            result_repo.fetch(source_repository, revision_id=revision_id)
1046
 
        elif result_repo is None:
1047
 
            # have source, and want to make a new target repo
1048
 
            result_repo = source_repository.sprout(result,
1049
 
                                                   revision_id=revision_id)
1050
 
        else:
1051
 
            # Fetch needed content into target.
1052
 
            # Would rather do it this way ...
1053
 
            # source_repository.copy_content_into(result_repo,
1054
 
            #                                     revision_id=revision_id)
1055
 
            # so we can override the copy method
1056
 
            if source_repository is not None:
1057
 
                result_repo.fetch(source_repository, revision_id=revision_id)
1058
1042
 
1059
1043
        # Create/update the result branch
1060
1044
        if source_branch is not None:
1063
1047
        else:
1064
1048
            result_branch = result.create_branch()
1065
1049
        repository_policy.configure_branch(result_branch)
1066
 
        if stacked_branch_url is not None:
1067
 
            result_branch.set_stacked_on(stacked_branch_url)
1068
1050
 
1069
1051
        # Create/update the result working tree
1070
1052
        if isinstance(target_transport, LocalTransport) and (
2738
2720
    for a branch that is being created.  The most basic policy decision is
2739
2721
    whether to create a new repository or use an existing one.
2740
2722
    """
2741
 
    def __init__(self, stack_on):
 
2723
    def __init__(self, stack_on, stack_on_pwd):
2742
2724
        self._stack_on = stack_on
 
2725
        self._stack_on_pwd = stack_on_pwd
2743
2726
 
2744
2727
    def configure_branch(self, branch):
2745
2728
        """Apply any configuration data from this policy to the branch.
2746
2729
 
2747
2730
        Default implementation sets repository stacking.
2748
2731
        """
2749
 
        if self._stack_on:
2750
 
            branch.set_stacked_on(self._stack_on)
 
2732
        if self._stack_on is not None:
 
2733
            if self._stack_on_pwd is None:
 
2734
                stack_on = self._stack_on
 
2735
            else:
 
2736
                stack_on = urlutils.rebase_url(self._stack_on,
 
2737
                    self._stack_on_pwd,
 
2738
                    branch.bzrdir.root_transport.base)
 
2739
            branch.set_stacked_on(stack_on)
2751
2740
 
2752
2741
    def _add_fallback(self, repository):
2753
2742
        if self._stack_on is None:
2775
2764
class CreateRepository(RepositoryAcquisitionPolicy):
2776
2765
    """A policy of creating a new repository"""
2777
2766
 
2778
 
    def __init__(self, bzrdir, stack_on=None):
2779
 
        RepositoryAcquisitionPolicy.__init__(self, stack_on)
 
2767
    def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None):
 
2768
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd)
2780
2769
        self._bzrdir = bzrdir
2781
2770
 
2782
2771
    def acquire_repository(self, make_working_trees=None, shared=False):
2794
2783
class UseExistingRepository(RepositoryAcquisitionPolicy):
2795
2784
    """A policy of reusing an existing repository"""
2796
2785
 
2797
 
    def __init__(self, repository, stack_on=None):
2798
 
        RepositoryAcquisitionPolicy.__init__(self, stack_on)
 
2786
    def __init__(self, repository, stack_on=None, stack_on_pwd=None):
 
2787
        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd)
2799
2788
        self._repository = repository
2800
2789
 
2801
2790
    def acquire_repository(self, make_working_trees=None, shared=False):