/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

• browse files at revision 4360.4.14
• compare with another revision
• compare with revision 5200.3.3
• download diff
• download tarball
• view history from revision 4360.4.14

Show diffs side-by-side

added

removed

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()."""

2699

2768

        del ie.text_id

2700

2769

 

2701

2770

    def get_parent_map(self, revision_ids):

2702

 

        """See graph._StackedParentsProvider.get_parent_map"""

 

2771

        """See graph.StackedParentsProvider.get_parent_map"""

2703

2772

        return dict((revision_id, self.revisions[revision_id])

2704

2773

                    for revision_id in revision_ids

2705

2774

                     if revision_id in self.revisions)

3049

3118

            return local_dir_format.initialize_on_transport(transport)

3050

3119

        client = _SmartClient(client_medium)

3051

3120

        path = client.remote_path_from_transport(transport)

3052

 

        response = client.call('BzrDirFormat.initialize', path)

 

3121

        try:

 

3122

            response = client.call('BzrDirFormat.initialize', path)

 

3123

        except errors.ErrorFromSmartServer, err:

 

3124

            remote._translate_error(err, path=path)

3053

3125

        if response[0] != 'ok':

3054

3126

            raise errors.SmartProtocolError('unexpected response code %s' % (response,))

3055

3127

        format = RemoteBzrDirFormat()

3103

3175

        if not do_vfs:

3104

3176

            client = _SmartClient(client_medium)

3105

3177

            path = client.remote_path_from_transport(transport)

3106

 

            if client_medium._is_remote_before((1, 15)):

 

3178

            if client_medium._is_remote_before((1, 16)):

3107

3179

                do_vfs = True

3108

3180

        if do_vfs:

3109

3181

            # TODO: lookup the local format from a server hint.

3115

3187

                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,

3116

3188

                make_working_trees=make_working_trees, shared_repo=shared_repo,

3117

3189

                vfs_only=True)

 

3190

        return self._initialize_on_transport_ex_rpc(client, path, transport,

 

3191

            use_existing_dir, create_prefix, force_new_repo, stacked_on,

 

3192

            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)

 

3193

 

 

3194

    def _initialize_on_transport_ex_rpc(self, client, path, transport,

 

3195

        use_existing_dir, create_prefix, force_new_repo, stacked_on,

 

3196

        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):

3118

3197

        args = []

3119

3198

        args.append(self._serialize_NoneTrueFalse(use_existing_dir))

3120

3199

        args.append(self._serialize_NoneTrueFalse(create_prefix))

3136

3215

            self._network_name = \

3137

3216

            BzrDirFormat.get_default_format().network_name()

3138

3217

        try:

3139

 

            response = client.call('BzrDirFormat.initialize_ex',

 

3218

            response = client.call('BzrDirFormat.initialize_ex_1.16',

3140

3219

                self.network_name(), path, *args)

3141

3220

        except errors.UnknownSmartMethod:

 

3221

            client._medium._remember_remote_is_before((1,16))

3142

3222

            local_dir_format = BzrDirMetaFormat1()

3143

3223

            self._supply_sub_formats_to(local_dir_format)

3144

3224

            return local_dir_format.initialize_on_transport_ex(transport,

3147

3227

                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,

3148

3228

                make_working_trees=make_working_trees, shared_repo=shared_repo,

3149

3229

                vfs_only=True)

 

3230

        except errors.ErrorFromSmartServer, err:

 

3231

            remote._translate_error(err, path=path)

3150

3232

        repo_path = response[0]

3151

3233

        bzrdir_name = response[6]

3152

3234

        require_stacking = response[7]

3168

3250

                repo_bzr = bzrdir

3169

3251

            final_stack = response[8] or None

3170

3252

            final_stack_pwd = response[9] or None

 

3253

            if final_stack_pwd:

 

3254

                final_stack_pwd = urlutils.join(

 

3255

                    transport.base, final_stack_pwd)

3171

3256

            remote_repo = remote.RemoteRepository(repo_bzr, repo_format)

3172

3257

            if len(response) > 10:

3173

3258

                # Updated server verb that locks remotely.

3520

3605

        """

3521

3606

        stack_on = self._get_full_stack_on()

3522

3607

        if stack_on:

3523

 

            # Stacking is desired. requested by the target, but does the place it

3524

 

            # points at support stacking? If it doesn't then we should

3525

 

            # not implicitly upgrade. We check this here.

3526

3608

            format = self._bzrdir._format

3527

 

            if not (format.repository_format.supports_external_lookups

3528

 

                and format.get_branch_format().supports_stacking()):

3529

 

                # May need to upgrade - but only do if the target also

3530

 

                # supports stacking. Note that this currently wastes

3531

 

                # network round trips to check - but we only do this

3532

 

                # when the source can't stack so it will fade away

3533

 

                # as people do upgrade.

3534

 

                branch_format = None

3535

 

                repo_format = None

3536

 

                try:

3537

 

                    target_dir = BzrDir.open(stack_on,

3538

 

                        possible_transports=[self._bzrdir.root_transport])

3539

 

                except errors.NotBranchError:

3540

 

                    # Nothing there, don't change formats

3541

 

                    pass

3542

 

                except errors.JailBreak:

3543

 

                    # stack_on is inaccessible, JFDI.

3544

 

                    if format.repository_format.rich_root_data:

3545

 

                        repo_format = pack_repo.RepositoryFormatKnitPack6RichRoot()

3546

 

                    else:

3547

 

                        repo_format = pack_repo.RepositoryFormatKnitPack6()

3548

 

                    branch_format = branch.BzrBranchFormat7()

3549

 

                else:

3550

 

                    try:

3551

 

                        target_branch = target_dir.open_branch()

3552

 

                    except errors.NotBranchError:

3553

 

                        # No branch, don't change formats

3554

 

                        pass

3555

 

                    else:

3556

 

                        branch_format = target_branch._format

3557

 

                        repo_format = target_branch.repository._format

3558

 

                        if not (branch_format.supports_stacking()

3559

 

                            and repo_format.supports_external_lookups):

3560

 

                            # Doesn't stack itself, don't force an upgrade

3561

 

                            branch_format = None

3562

 

                            repo_format = None

3563

 

                if branch_format and repo_format:

3564

 

                    # Does support stacking, use its format.

3565

 

                    format.repository_format = repo_format

3566

 

                    format.set_branch_format(branch_format)

3567

 

                    note('Source format does not support stacking, '

3568

 

                        'using format: \'%s\'\n  %s\n',

3569

 

                        branch_format.get_format_description(),

3570

 

                        repo_format.get_format_description())

 

3609

            format.require_stacking(stack_on=stack_on,

 

3610

                                    possible_transports=[self._bzrdir.root_transport])

3571

3611

            if not self._require_stacking:

3572

3612

                # We have picked up automatic stacking somewhere.

3573

3613

                note('Using default stacking branch %s at %s', self._stack_on,

3780

3820

    experimental=True,

3781

3821

    )

3782

3822

 

 

3823

format_registry.register_metadir('development7-rich-root',

 

3824

    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',

 

3825

    help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '

 

3826

        'rich roots. Please read '

 

3827

        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '

 

3828

        'before use.',

 

3829

    branch_format='bzrlib.branch.BzrBranchFormat7',

 

3830

    tree_format='bzrlib.workingtree.WorkingTreeFormat6',

 

3831

    hidden=True,

 

3832

    experimental=True,

 

3833

    )

 

3834

 

 

3835

format_registry.register_metadir('2a',

 

3836

    'bzrlib.repofmt.groupcompress_repo.RepositoryFormat2a',

 

3837

    help='First format for bzr 2.0 series.\n'

 

3838

        'Uses group-compress storage.\n'

 

3839

        'Provides rich roots which are a one-way transition.\n',

 

3840

        # 'storage in packs, 255-way hashed CHK inventory, bencode revision, group compress, '

 

3841

        # 'rich roots. Supported by bzr 1.16 and later.',

 

3842

    branch_format='bzrlib.branch.BzrBranchFormat7',

 

3843

    tree_format='bzrlib.workingtree.WorkingTreeFormat6',

 

3844

    experimental=True,

 

3845

    )

 

3846

 

3783

3847

# The following format should be an alias for the rich root equivalent 

3784

3848

# of the default format

3785

3849

format_registry.register_metadir('default-rich-root',

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0