← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Martin
  • Date: 2010-04-22 18:36:13 UTC
  • mto: (5177.1.1 integration2)
  • mto: This revision was merged to the branch mainline in revision 5179.
  • Revision ID: gzlist@googlemail.com-20100422183613-gruiwv2xsrjf0nhp
Fix more tests which were failing under -OO that had been missed earlier

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
504
504
                if (working.has_changes()):
505
505
                    raise errors.UncommittedChanges(working)
506
506
 
507
 
            if working.user_url != working.branch.user_url:
 
507
            working_path = working.bzrdir.root_transport.base
 
508
            branch_path = working.branch.bzrdir.root_transport.base
 
509
            if working_path != branch_path:
508
510
                raise errors.BzrCommandError("You cannot remove the working tree"
509
511
                                             " from a lightweight checkout")
510
512
 
528
530
        if tree:
529
531
            try:
530
532
                wt = WorkingTree.open_containing(location)[0]
531
 
                self.add_cleanup(wt.lock_read().unlock)
 
533
                wt.lock_read()
532
534
            except (errors.NoWorkingTree, errors.NotLocalUrl):
533
535
                raise errors.NoWorkingTree(location)
 
536
            self.add_cleanup(wt.unlock)
534
537
            revid = wt.last_revision()
535
538
            try:
536
539
                revno_t = wt.branch.revision_id_to_dotted_revno(revid)
539
542
            revno = ".".join(str(n) for n in revno_t)
540
543
        else:
541
544
            b = Branch.open_containing(location)[0]
542
 
            self.add_cleanup(b.lock_read().unlock)
 
545
            b.lock_read()
 
546
            self.add_cleanup(b.unlock)
543
547
            revno = b.revno()
544
548
        self.cleanup_now()
545
549
        self.outf.write(str(revno) + '\n')
568
572
        try:
569
573
            wt = WorkingTree.open_containing(directory)[0]
570
574
            b = wt.branch
571
 
            self.add_cleanup(wt.lock_read().unlock)
 
575
            wt.lock_read()
 
576
            self.add_cleanup(wt.unlock)
572
577
        except (errors.NoWorkingTree, errors.NotLocalUrl):
573
578
            wt = None
574
579
            b = Branch.open_containing(directory)[0]
575
 
            self.add_cleanup(b.lock_read().unlock)
 
580
            b.lock_read()
 
581
            self.add_cleanup(b.unlock)
576
582
        revision_ids = []
577
583
        if revision is not None:
578
584
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
677
683
                should_print=(not is_quiet()))
678
684
 
679
685
        if base_tree:
680
 
            self.add_cleanup(base_tree.lock_read().unlock)
 
686
            base_tree.lock_read()
 
687
            self.add_cleanup(base_tree.unlock)
681
688
        tree, file_list = tree_files_for_add(file_list)
682
689
        added, ignored = tree.smart_add(file_list, not
683
690
            no_recurse, action=action, save=not dry_run)
755
762
 
756
763
        revision = _get_one_revision('inventory', revision)
757
764
        work_tree, file_list = tree_files(file_list)
758
 
        self.add_cleanup(work_tree.lock_read().unlock)
 
765
        work_tree.lock_read()
 
766
        self.add_cleanup(work_tree.unlock)
759
767
        if revision is not None:
760
768
            tree = revision.as_tree(work_tree.branch)
761
769
 
762
770
            extra_trees = [work_tree]
763
 
            self.add_cleanup(tree.lock_read().unlock)
 
771
            tree.lock_read()
 
772
            self.add_cleanup(tree.unlock)
764
773
        else:
765
774
            tree = work_tree
766
775
            extra_trees = []
826
835
        if len(names_list) < 2:
827
836
            raise errors.BzrCommandError("missing file argument")
828
837
        tree, rel_names = tree_files(names_list, canonicalize=False)
829
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
838
        tree.lock_tree_write()
 
839
        self.add_cleanup(tree.unlock)
830
840
        self._run(tree, names_list, rel_names, after)
831
841
 
832
842
    def run_auto(self, names_list, after, dry_run):
837
847
            raise errors.BzrCommandError('--after cannot be specified with'
838
848
                                         ' --auto.')
839
849
        work_tree, file_list = tree_files(names_list, default_branch='.')
840
 
        self.add_cleanup(work_tree.lock_tree_write().unlock)
 
850
        work_tree.lock_tree_write()
 
851
        self.add_cleanup(work_tree.unlock)
841
852
        rename_map.RenameMap.guess_renames(work_tree, dry_run)
842
853
 
843
854
    def _run(self, tree, names_list, rel_names, after):
977
988
        try:
978
989
            tree_to = WorkingTree.open_containing(directory)[0]
979
990
            branch_to = tree_to.branch
980
 
            self.add_cleanup(tree_to.lock_write().unlock)
 
991
            tree_to.lock_write()
 
992
            self.add_cleanup(tree_to.unlock)
981
993
        except errors.NoWorkingTree:
982
994
            tree_to = None
983
995
            branch_to = Branch.open_containing(directory)[0]
984
 
            self.add_cleanup(branch_to.lock_write().unlock)
 
996
            branch_to.lock_write()
 
997
            self.add_cleanup(branch_to.unlock)
985
998
 
986
999
        if local and not branch_to.get_bound_location():
987
1000
            raise errors.LocalRequiresBoundBranch()
1018
1031
        else:
1019
1032
            branch_from = Branch.open(location,
1020
1033
                possible_transports=possible_transports)
1021
 
            self.add_cleanup(branch_from.lock_read().unlock)
 
1034
            branch_from.lock_read()
 
1035
            self.add_cleanup(branch_from.unlock)
1022
1036
 
1023
1037
            if branch_to.get_parent() is None or remember:
1024
1038
                branch_to.set_parent(branch_from.base)
1120
1134
        else:
1121
1135
            revision_id = None
1122
1136
        if tree is not None and revision_id is None:
1123
 
            tree.check_changed_or_out_of_date(
1124
 
                strict, 'push_strict',
1125
 
                more_error='Use --no-strict to force the push.',
1126
 
                more_warning='Uncommitted changes will not be pushed.')
 
1137
            tree.warn_if_changed_or_out_of_date(
 
1138
                strict, 'push_strict', 'Use --no-strict to force the push.')
1127
1139
        # Get the stacked_on branch, if any
1128
1140
        if stacked_on is not None:
1129
1141
            stacked_on = urlutils.normalize_url(stacked_on)
1207
1219
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1208
1220
            from_location)
1209
1221
        revision = _get_one_revision('branch', revision)
1210
 
        self.add_cleanup(br_from.lock_read().unlock)
 
1222
        br_from.lock_read()
 
1223
        self.add_cleanup(br_from.unlock)
1211
1224
        if revision is not None:
1212
1225
            revision_id = revision.as_revision_id(br_from)
1213
1226
        else:
1353
1366
    @display_command
1354
1367
    def run(self, dir=u'.'):
1355
1368
        tree = WorkingTree.open_containing(dir)[0]
1356
 
        self.add_cleanup(tree.lock_read().unlock)
 
1369
        tree.lock_read()
 
1370
        self.add_cleanup(tree.unlock)
1357
1371
        new_inv = tree.inventory
1358
1372
        old_tree = tree.basis_tree()
1359
 
        self.add_cleanup(old_tree.lock_read().unlock)
 
1373
        old_tree.lock_read()
 
1374
        self.add_cleanup(old_tree.unlock)
1360
1375
        old_inv = old_tree.inventory
1361
1376
        renames = []
1362
1377
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1400
1415
        master = branch.get_master_branch(
1401
1416
            possible_transports=possible_transports)
1402
1417
        if master is not None:
 
1418
            tree.lock_write()
1403
1419
            branch_location = master.base
1404
 
            tree.lock_write()
1405
1420
        else:
 
1421
            tree.lock_tree_write()
1406
1422
            branch_location = tree.branch.base
1407
 
            tree.lock_tree_write()
1408
1423
        self.add_cleanup(tree.unlock)
1409
1424
        # get rid of the final '/' and be ready for display
1410
1425
        branch_location = urlutils.unescape_for_display(
1530
1545
        if file_list is not None:
1531
1546
            file_list = [f for f in file_list]
1532
1547
 
1533
 
        self.add_cleanup(tree.lock_write().unlock)
 
1548
        tree.lock_write()
 
1549
        self.add_cleanup(tree.unlock)
1534
1550
        # Heuristics should probably all move into tree.remove_smart or
1535
1551
        # some such?
1536
1552
        if new:
1992
2008
    @display_command
1993
2009
    def run(self, show_ids=False):
1994
2010
        tree = WorkingTree.open_containing(u'.')[0]
1995
 
        self.add_cleanup(tree.lock_read().unlock)
 
2011
        tree.lock_read()
 
2012
        self.add_cleanup(tree.unlock)
1996
2013
        old = tree.basis_tree()
1997
 
        self.add_cleanup(old.lock_read().unlock)
 
2014
        old.lock_read()
 
2015
        self.add_cleanup(old.unlock)
1998
2016
        for path, ie in old.inventory.iter_entries():
1999
2017
            if not tree.has_id(ie.file_id):
2000
2018
                self.outf.write(path)
2042
2060
    @display_command
2043
2061
    def run(self, null=False):
2044
2062
        wt = WorkingTree.open_containing(u'.')[0]
2045
 
        self.add_cleanup(wt.lock_read().unlock)
 
2063
        wt.lock_read()
 
2064
        self.add_cleanup(wt.unlock)
2046
2065
        basis = wt.basis_tree()
2047
 
        self.add_cleanup(basis.lock_read().unlock)
 
2066
        basis.lock_read()
 
2067
        self.add_cleanup(basis.unlock)
2048
2068
        basis_inv = basis.inventory
2049
2069
        inv = wt.inventory
2050
2070
        for file_id in inv:
2279
2299
                   help='Show changes made in each revision as a patch.'),
2280
2300
            Option('include-merges',
2281
2301
                   help='Show merged revisions like --levels 0 does.'),
2282
 
            Option('exclude-common-ancestry',
2283
 
                   help='Display only the revisions that are not part'
2284
 
                   ' of both ancestries (require -rX..Y)'
2285
 
                   )
2286
2302
            ]
2287
2303
    encoding_type = 'replace'
2288
2304
 
2298
2314
            message=None,
2299
2315
            limit=None,
2300
2316
            show_diff=False,
2301
 
            include_merges=False,
2302
 
            exclude_common_ancestry=False,
2303
 
            ):
 
2317
            include_merges=False):
2304
2318
        from bzrlib.log import (
2305
2319
            Logger,
2306
2320
            make_log_request_dict,
2307
2321
            _get_info_for_log_files,
2308
2322
            )
2309
2323
        direction = (forward and 'forward') or 'reverse'
2310
 
        if (exclude_common_ancestry
2311
 
            and (revision is None or len(revision) != 2)):
2312
 
            raise errors.BzrCommandError(
2313
 
                '--exclude-common-ancestry requires -r with two revisions')
2314
2324
        if include_merges:
2315
2325
            if levels is None:
2316
2326
                levels = 0
2332
2342
        if file_list:
2333
2343
            # find the file ids to log and check for directory filtering
2334
2344
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2335
 
                revision, file_list, self.add_cleanup)
 
2345
                revision, file_list)
 
2346
            self.add_cleanup(b.unlock)
2336
2347
            for relpath, file_id, kind in file_info_list:
2337
2348
                if file_id is None:
2338
2349
                    raise errors.BzrCommandError(
2356
2367
                location = '.'
2357
2368
            dir, relpath = bzrdir.BzrDir.open_containing(location)
2358
2369
            b = dir.open_branch()
2359
 
            self.add_cleanup(b.lock_read().unlock)
 
2370
            b.lock_read()
 
2371
            self.add_cleanup(b.unlock)
2360
2372
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2361
2373
 
2362
2374
        # Decide on the type of delta & diff filtering to use
2407
2419
            direction=direction, specific_fileids=file_ids,
2408
2420
            start_revision=rev1, end_revision=rev2, limit=limit,
2409
2421
            message_search=message, delta_type=delta_type,
2410
 
            diff_type=diff_type, _match_using_deltas=match_using_deltas,
2411
 
            exclude_common_ancestry=exclude_common_ancestry,
2412
 
            )
 
2422
            diff_type=diff_type, _match_using_deltas=match_using_deltas)
2413
2423
        Logger(b, rqst).show(lf)
2414
2424
 
2415
2425
 
2486
2496
        tree, relpath = WorkingTree.open_containing(filename)
2487
2497
        file_id = tree.path2id(relpath)
2488
2498
        b = tree.branch
2489
 
        self.add_cleanup(b.lock_read().unlock)
 
2499
        b.lock_read()
 
2500
        self.add_cleanup(b.unlock)
2490
2501
        touching_revs = log.find_touching_revisions(b, file_id)
2491
2502
        for revno, revision_id, what in touching_revs:
2492
2503
            self.outf.write("%6d %s\n" % (revno, what))
2561
2572
                view_str = views.view_display_str(view_files)
2562
2573
                note("Ignoring files outside view. View is %s" % view_str)
2563
2574
 
2564
 
        self.add_cleanup(tree.lock_read().unlock)
 
2575
        tree.lock_read()
 
2576
        self.add_cleanup(tree.unlock)
2565
2577
        for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2566
2578
            from_dir=relpath, recursive=recursive):
2567
2579
            # Apply additional masking
2637
2649
    using this command or directly by using an editor, be sure to commit
2638
2650
    it.
2639
2651
    
2640
 
    Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2641
 
    the global ignore file can be found in the application data directory as
2642
 
    C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2643
 
    Global ignores are not touched by this command. The global ignore file
2644
 
    can be edited directly using an editor.
2645
 
 
2646
2652
    Patterns prefixed with '!' are exceptions to ignore patterns and take
2647
2653
    precedence over regular ignores.  Such exceptions are used to specify
2648
2654
    files that should be versioned which would otherwise be ignored.
2689
2695
    _see_also = ['status', 'ignored', 'patterns']
2690
2696
    takes_args = ['name_pattern*']
2691
2697
    takes_options = [
2692
 
        Option('default-rules',
2693
 
               help='Display the default ignore rules that bzr uses.')
 
2698
        Option('old-default-rules',
 
2699
               help='Write out the ignore rules bzr < 0.9 always used.')
2694
2700
        ]
2695
2701
 
2696
 
    def run(self, name_pattern_list=None, default_rules=None):
 
2702
    def run(self, name_pattern_list=None, old_default_rules=None):
2697
2703
        from bzrlib import ignores
2698
 
        if default_rules is not None:
2699
 
            # dump the default rules and exit
2700
 
            for pattern in ignores.USER_DEFAULTS:
 
2704
        if old_default_rules is not None:
 
2705
            # dump the rules and exit
 
2706
            for pattern in ignores.OLD_DEFAULTS:
2701
2707
                self.outf.write("%s\n" % pattern)
2702
2708
            return
2703
2709
        if not name_pattern_list:
2704
2710
            raise errors.BzrCommandError("ignore requires at least one "
2705
 
                "NAME_PATTERN or --default-rules.")
 
2711
                                  "NAME_PATTERN or --old-default-rules")
2706
2712
        name_pattern_list = [globbing.normalize_pattern(p)
2707
2713
                             for p in name_pattern_list]
2708
2714
        for name_pattern in name_pattern_list:
2746
2752
    @display_command
2747
2753
    def run(self):
2748
2754
        tree = WorkingTree.open_containing(u'.')[0]
2749
 
        self.add_cleanup(tree.lock_read().unlock)
 
2755
        tree.lock_read()
 
2756
        self.add_cleanup(tree.unlock)
2750
2757
        for path, file_class, kind, file_id, entry in tree.list_files():
2751
2758
            if file_class != 'I':
2752
2759
                continue
2865
2872
                                         " one revision specifier")
2866
2873
        tree, branch, relpath = \
2867
2874
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2868
 
        self.add_cleanup(branch.lock_read().unlock)
 
2875
        branch.lock_read()
 
2876
        self.add_cleanup(branch.unlock)
2869
2877
        return self._run(tree, branch, relpath, filename, revision,
2870
2878
                         name_from_revision, filters)
2871
2879
 
2874
2882
        if tree is None:
2875
2883
            tree = b.basis_tree()
2876
2884
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2877
 
        self.add_cleanup(rev_tree.lock_read().unlock)
 
2885
        rev_tree.lock_read()
 
2886
        self.add_cleanup(rev_tree.unlock)
2878
2887
 
2879
2888
        old_file_id = rev_tree.path2id(relpath)
2880
2889
 
3046
3055
                         "the master branch until a normal commit "
3047
3056
                         "is performed."
3048
3057
                    ),
3049
 
             Option('show-diff', short_name='p',
 
3058
             Option('show-diff',
3050
3059
                    help='When no message is supplied, show the diff along'
3051
3060
                    ' with the status summary in the message editor.'),
3052
3061
             ]
3583
3592
                raise errors.BzrCommandError("subunit not available. subunit "
3584
3593
                    "needs to be installed to use --subunit.")
3585
3594
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3586
 
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3587
 
            # stdout, which would corrupt the subunit stream. 
3588
 
            if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3589
 
                import msvcrt
3590
 
                msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3591
3595
        if parallel:
3592
3596
            self.additional_selftest_args.setdefault(
3593
3597
                'suite_decorators', []).append(parallel)
3663
3667
 
3664
3668
        branch1 = Branch.open_containing(branch)[0]
3665
3669
        branch2 = Branch.open_containing(other)[0]
3666
 
        self.add_cleanup(branch1.lock_read().unlock)
3667
 
        self.add_cleanup(branch2.lock_read().unlock)
 
3670
        branch1.lock_read()
 
3671
        self.add_cleanup(branch1.unlock)
 
3672
        branch2.lock_read()
 
3673
        self.add_cleanup(branch2.unlock)
3668
3674
        last1 = ensure_null(branch1.last_revision())
3669
3675
        last2 = ensure_null(branch2.last_revision())
3670
3676
 
3808
3814
            unversioned_filter=tree.is_ignored, view_info=view_info)
3809
3815
        pb = ui.ui_factory.nested_progress_bar()
3810
3816
        self.add_cleanup(pb.finished)
3811
 
        self.add_cleanup(tree.lock_write().unlock)
 
3817
        tree.lock_write()
 
3818
        self.add_cleanup(tree.unlock)
3812
3819
        if location is not None:
3813
3820
            try:
3814
3821
                mergeable = bundle.read_mergeable_from_url(location,
4070
4077
        if merge_type is None:
4071
4078
            merge_type = _mod_merge.Merge3Merger
4072
4079
        tree, file_list = tree_files(file_list)
4073
 
        self.add_cleanup(tree.lock_write().unlock)
 
4080
        tree.lock_write()
 
4081
        self.add_cleanup(tree.unlock)
4074
4082
        parents = tree.get_parent_ids()
4075
4083
        if len(parents) != 2:
4076
4084
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
4186
4194
    def run(self, revision=None, no_backup=False, file_list=None,
4187
4195
            forget_merges=None):
4188
4196
        tree, file_list = tree_files(file_list)
4189
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
4197
        tree.lock_tree_write()
 
4198
        self.add_cleanup(tree.unlock)
4190
4199
        if forget_merges:
4191
4200
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4192
4201
        else:
4328
4337
            restrict = 'remote'
4329
4338
 
4330
4339
        local_branch = Branch.open_containing(u".")[0]
4331
 
        self.add_cleanup(local_branch.lock_read().unlock)
 
4340
        local_branch.lock_read()
 
4341
        self.add_cleanup(local_branch.unlock)
4332
4342
 
4333
4343
        parent = local_branch.get_parent()
4334
4344
        if other_branch is None:
4345
4355
        if remote_branch.base == local_branch.base:
4346
4356
            remote_branch = local_branch
4347
4357
        else:
4348
 
            self.add_cleanup(remote_branch.lock_read().unlock)
 
4358
            remote_branch.lock_read()
 
4359
            self.add_cleanup(remote_branch.unlock)
4349
4360
 
4350
4361
        local_revid_range = _revision_range_to_revid_range(
4351
4362
            _get_revision_range(my_revision, local_branch,
4406
4417
            message("Branches are up to date.\n")
4407
4418
        self.cleanup_now()
4408
4419
        if not status_code and parent is None and other_branch is not None:
4409
 
            self.add_cleanup(local_branch.lock_write().unlock)
 
4420
            local_branch.lock_write()
 
4421
            self.add_cleanup(local_branch.unlock)
4410
4422
            # handle race conditions - a parent might be set while we run.
4411
4423
            if local_branch.get_parent() is None:
4412
4424
                local_branch.set_parent(remote_branch.base)
4512
4524
            b = Branch.open_containing(branch)[0]
4513
4525
        else:
4514
4526
            b = Branch.open(branch)
4515
 
        self.add_cleanup(b.lock_read().unlock)
 
4527
        b.lock_read()
 
4528
        self.add_cleanup(b.unlock)
4516
4529
        if revision is None:
4517
4530
            rev_id = b.last_revision()
4518
4531
        else:
4552
4565
        wt, branch, relpath = \
4553
4566
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4554
4567
        if wt is not None:
4555
 
            self.add_cleanup(wt.lock_read().unlock)
 
4568
            wt.lock_read()
 
4569
            self.add_cleanup(wt.unlock)
4556
4570
        else:
4557
 
            self.add_cleanup(branch.lock_read().unlock)
 
4571
            branch.lock_read()
 
4572
            self.add_cleanup(branch.unlock)
4558
4573
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4559
 
        self.add_cleanup(tree.lock_read().unlock)
 
4574
        tree.lock_read()
 
4575
        self.add_cleanup(tree.unlock)
4560
4576
        if wt is not None:
4561
4577
            file_id = wt.path2id(relpath)
4562
4578
        else:
4588
4604
        if revision_id_list is None and revision is None:
4589
4605
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4590
4606
        b = WorkingTree.open_containing(u'.')[0].branch
4591
 
        self.add_cleanup(b.lock_write().unlock)
 
4607
        b.lock_write()
 
4608
        self.add_cleanup(b.unlock)
4592
4609
        return self._run(b, revision_id_list, revision)
4593
4610
 
4594
4611
    def _run(self, b, revision_id_list, revision):
4641
4658
 
4642
4659
class cmd_bind(Command):
4643
4660
    __doc__ = """Convert the current branch into a checkout of the supplied branch.
4644
 
    If no branch is supplied, rebind to the last bound location.
4645
4661
 
4646
4662
    Once converted into a checkout, commits must succeed on the master branch
4647
4663
    before they will be applied to the local branch.
4744
4760
            b = control.open_branch()
4745
4761
 
4746
4762
        if tree is not None:
4747
 
            self.add_cleanup(tree.lock_write().unlock)
 
4763
            tree.lock_write()
 
4764
            self.add_cleanup(tree.unlock)
4748
4765
        else:
4749
 
            self.add_cleanup(b.lock_write().unlock)
 
4766
            b.lock_write()
 
4767
            self.add_cleanup(b.unlock)
4750
4768
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4751
4769
 
4752
4770
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
5315
5333
            revision=None,
5316
5334
            ):
5317
5335
        branch, relpath = Branch.open_containing(directory)
5318
 
        self.add_cleanup(branch.lock_write().unlock)
 
5336
        branch.lock_write()
 
5337
        self.add_cleanup(branch.unlock)
5319
5338
        if delete:
5320
5339
            if tag_name is None:
5321
5340
                raise errors.BzrCommandError("No tag specified to delete.")
5376
5395
        if not tags:
5377
5396
            return
5378
5397
 
5379
 
        self.add_cleanup(branch.lock_read().unlock)
 
5398
        branch.lock_read()
 
5399
        self.add_cleanup(branch.unlock)
5380
5400
        if revision:
5381
5401
            graph = branch.repository.get_graph()
5382
5402
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5860
5880
 
5861
5881
    def run_for_list(self):
5862
5882
        tree = WorkingTree.open_containing('.')[0]
5863
 
        self.add_cleanup(tree.lock_read().unlock)
 
5883
        tree.lock_read()
 
5884
        self.add_cleanup(tree.unlock)
5864
5885
        manager = tree.get_shelf_manager()
5865
5886
        shelves = manager.active_shelves()
5866
5887
        if len(shelves) == 0: