← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

(jam) BzrDirFormat1.require_stacking upgrades the branch separate
        from the repo.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
2358
2358
    def set_branch_format(self, format):
2359
2359
        self._branch_format = format
2360
2360
 
2361
 
    def require_stacking(self):
 
2361
    def require_stacking(self, stack_on=None, possible_transports=None):
 
2362
        """We have a request to stack, try to ensure the formats support it.
 
2363
 
 
2364
        :param stack_on: If supplied, it is the URL to a branch that we want to
 
2365
            stack on. Check to see if that format supports stacking before
 
2366
            forcing an upgrade.
 
2367
        """
 
2368
        # Stacking is desired. requested by the target, but does the place it
 
2369
        # points at support stacking? If it doesn't then we should
 
2370
        # not implicitly upgrade. We check this here.
 
2371
        new_repo_format = None
 
2372
        new_branch_format = None
 
2373
 
 
2374
        # a bit of state for get_target_branch so that we don't try to open it
 
2375
        # 2 times, for both repo *and* branch
 
2376
        target = [None, False, None] # target_branch, checked, upgrade anyway
 
2377
        def get_target_branch():
 
2378
            if target[1]:
 
2379
                # We've checked, don't check again
 
2380
                return target
 
2381
            if stack_on is None:
 
2382
                # No target format, that means we want to force upgrading
 
2383
                target[:] = [None, True, True]
 
2384
                return target
 
2385
            try:
 
2386
                target_dir = BzrDir.open(stack_on,
 
2387
                    possible_transports=possible_transports)
 
2388
            except errors.NotBranchError:
 
2389
                # Nothing there, don't change formats
 
2390
                target[:] = [None, True, False]
 
2391
                return target
 
2392
            except errors.JailBreak:
 
2393
                # JailBreak, JFDI and upgrade anyway
 
2394
                target[:] = [None, True, True]
 
2395
                return target
 
2396
            try:
 
2397
                target_branch = target_dir.open_branch()
 
2398
            except errors.NotBranchError:
 
2399
                # No branch, don't upgrade formats
 
2400
                target[:] = [None, True, False]
 
2401
                return target
 
2402
            target[:] = [target_branch, True, False]
 
2403
            return target
 
2404
 
 
2405
        if not (self.repository_format.supports_external_lookups):
 
2406
            # We need to upgrade the Repository.
 
2407
            target_branch, _, do_upgrade = get_target_branch()
 
2408
            if target_branch is None:
 
2409
                # We don't have a target branch, should we upgrade anyway?
 
2410
                if do_upgrade:
 
2411
                    # stack_on is inaccessible, JFDI.
 
2412
                    # TODO: bad monkey, hard-coded formats...
 
2413
                    if self.repository_format.rich_root_data:
 
2414
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
 
2415
                    else:
 
2416
                        new_repo_format = pack_repo.RepositoryFormatKnitPack5()
 
2417
            else:
 
2418
                # If the target already supports stacking, then we know the
 
2419
                # project is already able to use stacking, so auto-upgrade
 
2420
                # for them
 
2421
                new_repo_format = target_branch.repository._format
 
2422
                if not new_repo_format.supports_external_lookups:
 
2423
                    # target doesn't, source doesn't, so don't auto upgrade
 
2424
                    # repo
 
2425
                    new_repo_format = None
 
2426
            if new_repo_format is not None:
 
2427
                self.repository_format = new_repo_format
 
2428
                note('Source repository format does not support stacking,'
 
2429
                     ' using format:\n  %s',
 
2430
                     new_repo_format.get_format_description())
 
2431
 
2362
2432
        if not self.get_branch_format().supports_stacking():
2363
 
            # We need to make a stacked branch, but the default format for the
2364
 
            # target doesn't support stacking.  So force a branch that *can*
2365
 
            # support stacking.
2366
 
            from bzrlib.branch import BzrBranchFormat7
2367
 
            branch_format = BzrBranchFormat7()
2368
 
            self.set_branch_format(branch_format)
2369
 
            mutter("using %r for stacking" % (branch_format,))
2370
 
            from bzrlib.repofmt import pack_repo
2371
 
            if self.repository_format.rich_root_data:
2372
 
                bzrdir_format_name = '1.6.1-rich-root'
2373
 
                repo_format = pack_repo.RepositoryFormatKnitPack5RichRoot()
 
2433
            # We just checked the repo, now lets check if we need to
 
2434
            # upgrade the branch format
 
2435
            target_branch, _, do_upgrade = get_target_branch()
 
2436
            if target_branch is None:
 
2437
                if do_upgrade:
 
2438
                    # TODO: bad monkey, hard-coded formats...
 
2439
                    new_branch_format = branch.BzrBranchFormat7()
2374
2440
            else:
2375
 
                bzrdir_format_name = '1.6'
2376
 
                repo_format = pack_repo.RepositoryFormatKnitPack5()
2377
 
            note('Source format does not support stacking, using format:'
2378
 
                 ' \'%s\'\n  %s\n',
2379
 
                 bzrdir_format_name, repo_format.get_format_description())
2380
 
            self.repository_format = repo_format
 
2441
                new_branch_format = target_branch._format
 
2442
                if not new_branch_format.supports_stacking():
 
2443
                    new_branch_format = None
 
2444
            if new_branch_format is not None:
 
2445
                # Does support stacking, use its format.
 
2446
                self.set_branch_format(new_branch_format)
 
2447
                note('Source branch format does not support stacking,'
 
2448
                     ' using format:\n  %s',
 
2449
                     new_branch_format.get_format_description())
2381
2450
 
2382
2451
    def get_converter(self, format=None):
2383
2452
        """See BzrDirFormat.get_converter()."""
3532
3601
        """
3533
3602
        stack_on = self._get_full_stack_on()
3534
3603
        if stack_on:
3535
 
            # Stacking is desired. requested by the target, but does the place it
3536
 
            # points at support stacking? If it doesn't then we should
3537
 
            # not implicitly upgrade. We check this here.
3538
3604
            format = self._bzrdir._format
3539
 
            if not (format.repository_format.supports_external_lookups
3540
 
                and format.get_branch_format().supports_stacking()):
3541
 
                # May need to upgrade - but only do if the target also
3542
 
                # supports stacking. Note that this currently wastes
3543
 
                # network round trips to check - but we only do this
3544
 
                # when the source can't stack so it will fade away
3545
 
                # as people do upgrade.
3546
 
                branch_format = None
3547
 
                repo_format = None
3548
 
                try:
3549
 
                    target_dir = BzrDir.open(stack_on,
3550
 
                        possible_transports=[self._bzrdir.root_transport])
3551
 
                except errors.NotBranchError:
3552
 
                    # Nothing there, don't change formats
3553
 
                    pass
3554
 
                except errors.JailBreak:
3555
 
                    # stack_on is inaccessible, JFDI.
3556
 
                    if format.repository_format.rich_root_data:
3557
 
                        repo_format = pack_repo.RepositoryFormatKnitPack6RichRoot()
3558
 
                    else:
3559
 
                        repo_format = pack_repo.RepositoryFormatKnitPack6()
3560
 
                    branch_format = branch.BzrBranchFormat7()
3561
 
                else:
3562
 
                    try:
3563
 
                        target_branch = target_dir.open_branch()
3564
 
                    except errors.NotBranchError:
3565
 
                        # No branch, don't change formats
3566
 
                        pass
3567
 
                    else:
3568
 
                        branch_format = target_branch._format
3569
 
                        repo_format = target_branch.repository._format
3570
 
                        if not (branch_format.supports_stacking()
3571
 
                            and repo_format.supports_external_lookups):
3572
 
                            # Doesn't stack itself, don't force an upgrade
3573
 
                            branch_format = None
3574
 
                            repo_format = None
3575
 
                if branch_format and repo_format:
3576
 
                    # Does support stacking, use its format.
3577
 
                    format.repository_format = repo_format
3578
 
                    format.set_branch_format(branch_format)
3579
 
                    note('Source format does not support stacking, '
3580
 
                        'using format: \'%s\'\n  %s\n',
3581
 
                        branch_format.get_format_description(),
3582
 
                        repo_format.get_format_description())
 
3605
            format.require_stacking(stack_on=stack_on,
 
3606
                                    possible_transports=[self._bzrdir.root_transport])
3583
3607
            if not self._require_stacking:
3584
3608
                # We have picked up automatic stacking somewhere.
3585
3609
                note('Using default stacking branch %s at %s', self._stack_on,