/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/dir.py

  • Committer: Jelmer Vernooij
  • Date: 2018-06-14 17:59:16 UTC
  • mto: This revision was merged to the branch mainline in revision 7065.
  • Revision ID: jelmer@jelmer.uk-20180614175916-a2e2xh5k533guq1x
Move breezy.plugins.git to breezy.git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/dir.py
17
17
 
18
18
"""An adapter between a Git control dir and a Bazaar ControlDir."""
19
19
 
20
 
import contextlib
 
20
from __future__ import absolute_import
 
21
 
 
22
import urllib
21
23
 
22
24
from .. import (
23
25
    branch as _mod_branch,
24
 
    errors as brz_errors,
 
26
    errors as bzr_errors,
25
27
    trace,
26
28
    osutils,
 
29
    repository as _mod_repository,
 
30
    revision as _mod_revision,
27
31
    urlutils,
28
32
    )
29
33
from ..transport import (
38
42
    format_registry,
39
43
    RepositoryAcquisitionPolicy,
40
44
    )
 
45
from .object_store import (
 
46
    get_object_store,
 
47
    )
41
48
 
42
 
from .mapping import (
43
 
    decode_git_path,
44
 
    encode_git_path,
45
 
    )
46
49
from .push import (
47
50
    GitPushResult,
48
51
    )
58
61
        return None
59
62
 
60
63
    def set_default_stack_on(self, value):
61
 
        raise brz_errors.BzrError("Cannot set configuration")
 
64
        raise bzr_errors.BzrError("Cannot set configuration")
62
65
 
63
66
 
64
67
class GitControlDirFormat(ControlDirFormat):
73
76
        return True
74
77
 
75
78
    def network_name(self):
76
 
        return b"git"
 
79
        return "git"
77
80
 
78
81
 
79
82
class UseExistingRepository(RepositoryAcquisitionPolicy):
89
92
            relative to.
90
93
        """
91
94
        super(UseExistingRepository, self).__init__(
92
 
            stack_on, stack_on_pwd, require_stacking)
 
95
                stack_on, stack_on_pwd, require_stacking)
93
96
        self._repository = repository
94
97
 
95
98
    def acquire_repository(self, make_working_trees=None, shared=False,
96
 
                           possible_transports=None):
 
99
            possible_transports=None):
97
100
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
98
101
 
99
102
        Returns an existing repository to use.
122
125
 
123
126
    def _get_selected_ref(self, branch, ref=None):
124
127
        if ref is not None and branch is not None:
125
 
            raise brz_errors.BzrError("can't specify both ref and branch")
 
128
            raise bzr_errors.BzrError("can't specify both ref and branch")
126
129
        if ref is not None:
127
130
            return ref
128
131
        if branch is not None:
132
135
            self.user_transport, "get_segment_parameters", lambda: {})()
133
136
        ref = segment_parameters.get("ref")
134
137
        if ref is not None:
135
 
            return urlutils.unquote_to_bytes(ref)
 
138
            return urlutils.unescape(ref)
136
139
        if branch is None and getattr(self, "_get_selected_branch", False):
137
140
            branch = self._get_selected_branch()
138
141
            if branch is not None:
159
162
        # Create/update the result branch
160
163
        try:
161
164
            result = ControlDir.open_from_transport(target_transport)
162
 
        except brz_errors.NotBranchError:
 
165
        except bzr_errors.NotBranchError:
163
166
            result = cloning_format.initialize_on_transport(target_transport)
164
167
        source_branch = self.open_branch()
165
168
        source_repository = self.find_repository()
166
169
        try:
167
170
            result_repo = result.find_repository()
168
 
        except brz_errors.NoRepositoryPresent:
 
171
        except bzr_errors.NoRepositoryPresent:
169
172
            result_repo = result.create_repository()
 
173
            target_is_empty = True
 
174
        else:
 
175
            target_is_empty = None # Unknown
170
176
        if stacked:
171
 
            raise _mod_branch.UnstackableBranchFormat(
172
 
                self._format, self.user_url)
 
177
            raise _mod_branch.UnstackableBranchFormat(self._format, self.user_url)
173
178
        interrepo = InterRepository.get(source_repository, result_repo)
174
179
 
175
180
        if revision_id is not None:
178
183
        else:
179
184
            determine_wants = interrepo.determine_wants_all
180
185
        interrepo.fetch_objects(determine_wants=determine_wants,
181
 
                                mapping=source_branch.mapping)
182
 
        result_branch = source_branch.sprout(
183
 
            result, revision_id=revision_id, repository=result_repo)
184
 
        if (create_tree_if_local and
185
 
            result.open_branch(name="").name == result_branch.name and
186
 
            isinstance(target_transport, LocalTransport) and
187
 
                (result_repo is None or result_repo.make_working_trees())):
188
 
            wt = result.create_workingtree(
189
 
                accelerator_tree=accelerator_tree,
 
186
            mapping=source_branch.mapping)
 
187
        result_branch = source_branch.sprout(result,
 
188
            revision_id=revision_id, repository=result_repo)
 
189
        if (create_tree_if_local
 
190
            and isinstance(target_transport, LocalTransport)
 
191
            and (result_repo is None or result_repo.make_working_trees())):
 
192
            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
190
193
                hardlink=hardlink, from_branch=result_branch)
191
 
        else:
192
 
            wt = None
193
 
        if recurse == 'down':
194
 
            with contextlib.ExitStack() as stack:
195
 
                basis = None
196
 
                if wt is not None:
197
 
                    basis = wt.basis_tree()
198
 
                elif result_branch is not None:
199
 
                    basis = result_branch.basis_tree()
200
 
                elif source_branch is not None:
201
 
                    basis = source_branch.basis_tree()
202
 
                if basis is not None:
203
 
                    stack.enter_context(basis.lock_read())
204
 
                    subtrees = basis.iter_references()
205
 
                else:
206
 
                    subtrees = []
207
 
                for path in subtrees:
208
 
                    target = urlutils.join(url, urlutils.escape(path))
209
 
                    sublocation = wt.reference_parent(
210
 
                        path, possible_transports=possible_transports)
211
 
                    if sublocation is None:
212
 
                        trace.warning(
213
 
                            'Ignoring nested tree %s, parent location unknown.',
214
 
                            path)
215
 
                        continue
216
 
                    sublocation.controldir.sprout(
217
 
                        target, basis.get_reference_revision(path),
218
 
                        force_new_repo=force_new_repo, recurse=recurse,
219
 
                        stacked=stacked)
220
 
        if getattr(result_repo, '_git', None):
221
 
            # Don't leak resources:
222
 
            # TODO(jelmer): This shouldn't be git-specific, and possibly
223
 
            # just use read locks.
224
 
            result_repo._git.object_store.close()
225
194
        return result
226
195
 
227
196
    def clone_on_transport(self, transport, revision_id=None,
228
 
                           force_new_repo=False, preserve_stacking=False,
229
 
                           stacked_on=None, create_prefix=False,
230
 
                           use_existing_dir=True, no_tree=False,
231
 
                           tag_selector=None):
 
197
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
 
198
        create_prefix=False, use_existing_dir=True, no_tree=False):
232
199
        """See ControlDir.clone_on_transport."""
233
200
        from ..repository import InterRepository
234
201
        from .mapping import default_mapping
235
 
        from ..transport.local import LocalTransport
236
202
        if stacked_on is not None:
237
 
            raise _mod_branch.UnstackableBranchFormat(
238
 
                self._format, self.user_url)
 
203
            raise _mod_branch.UnstackableBranchFormat(self._format, self.user_url)
239
204
        if no_tree:
240
205
            format = BareLocalGitControlDirFormat()
241
206
        else:
242
207
            format = LocalGitControlDirFormat()
243
208
        (target_repo, target_controldir, stacking,
244
 
         repo_policy) = format.initialize_on_transport_ex(
245
 
            transport, use_existing_dir=use_existing_dir,
246
 
            create_prefix=create_prefix,
247
 
            force_new_repo=force_new_repo)
 
209
                repo_policy) = format.initialize_on_transport_ex(
 
210
                        transport, use_existing_dir=use_existing_dir,
 
211
                        create_prefix=create_prefix,
 
212
                        force_new_repo=force_new_repo)
248
213
        target_repo = target_controldir.find_repository()
249
214
        target_git_repo = target_repo._git
250
215
        source_repo = self.find_repository()
 
216
        source_git_repo = source_repo._git
251
217
        interrepo = InterRepository.get(source_repo, target_repo)
252
218
        if revision_id is not None:
253
 
            determine_wants = interrepo.get_determine_wants_revids(
254
 
                [revision_id], include_tags=True, tag_selector=tag_selector)
 
219
            determine_wants = interrepo.get_determine_wants_revids([revision_id], include_tags=True)
255
220
        else:
256
221
            determine_wants = interrepo.determine_wants_all
257
222
        (pack_hint, _, refs) = interrepo.fetch_objects(determine_wants,
258
 
                                                       mapping=default_mapping)
259
 
        for name, val in refs.items():
 
223
            mapping=default_mapping)
 
224
        for name, val in refs.iteritems():
260
225
            target_git_repo.refs[name] = val
261
 
        result_dir = LocalGitDir(transport, target_git_repo, format)
 
226
        result_dir = self.__class__(transport, target_git_repo, format)
262
227
        if revision_id is not None:
263
228
            result_dir.open_branch().set_last_revision(revision_id)
264
 
        if not no_tree and isinstance(result_dir.root_transport, LocalTransport):
 
229
        try:
 
230
            # Cheaper to check if the target is not local, than to try making
 
231
            # the tree and fail.
 
232
            result_dir.root_transport.local_abspath('.')
265
233
            if result_dir.open_repository().make_working_trees():
266
 
                try:
267
 
                    local_wt = self.open_workingtree()
268
 
                except brz_errors.NoWorkingTree:
269
 
                    pass
270
 
                except brz_errors.NotLocalUrl:
271
 
                    result_dir.create_workingtree(revision_id=revision_id)
272
 
                else:
273
 
                    local_wt.clone(result_dir, revision_id=revision_id)
 
234
                self.open_workingtree().clone(result_dir, revision_id=revision_id)
 
235
        except (bzr_errors.NoWorkingTree, bzr_errors.NotLocalUrl):
 
236
            pass
274
237
 
275
238
        return result_dir
276
239
 
305
268
        """
306
269
        return UseExistingRepository(self.find_repository())
307
270
 
308
 
    def branch_names(self):
309
 
        from .refs import ref_to_branch_name
310
 
        ret = []
311
 
        for ref in self.get_refs_container().keys():
312
 
            try:
313
 
                branch_name = ref_to_branch_name(ref)
314
 
            except UnicodeDecodeError:
315
 
                trace.warning("Ignoring branch %r with unicode error ref", ref)
316
 
                continue
317
 
            except ValueError:
318
 
                continue
319
 
            ret.append(branch_name)
320
 
        return ret
321
 
 
322
271
    def get_branches(self):
323
272
        from .refs import ref_to_branch_name
324
273
        ret = {}
325
274
        for ref in self.get_refs_container().keys():
326
275
            try:
327
276
                branch_name = ref_to_branch_name(ref)
 
277
            except ValueError:
 
278
                continue
328
279
            except UnicodeDecodeError:
329
280
                trace.warning("Ignoring branch %r with unicode error ref", ref)
330
281
                continue
331
 
            except ValueError:
332
 
                continue
333
282
            ret[branch_name] = self.open_branch(ref=ref)
334
283
        return ret
335
284
 
336
285
    def list_branches(self):
337
 
        return list(self.get_branches().values())
 
286
        return self.get_branches().values()
338
287
 
339
288
    def push_branch(self, source, revision_id=None, overwrite=False,
340
289
                    remember=False, create_prefix=False, lossy=False,
341
 
                    name=None, tag_selector=None):
 
290
                    name=None):
342
291
        """Push the source branch into this ControlDir."""
343
292
        push_result = GitPushResult()
344
293
        push_result.workingtree_updated = None
345
294
        push_result.master_branch = None
346
295
        push_result.source_branch = source
347
296
        push_result.stacked_on = None
 
297
        repo = self.find_repository()
 
298
        refname = self._get_selected_ref(name)
348
299
        from .branch import GitBranch
349
300
        if isinstance(source, GitBranch) and lossy:
350
 
            raise brz_errors.LossyPushToSameVCS(source.controldir, self)
 
301
            raise bzr_errors.LossyPushToSameVCS(source.controldir, self)
351
302
        target = self.open_branch(name, nascent_ok=True)
352
303
        push_result.branch_push_result = source.push(
353
 
            target, overwrite=overwrite, stop_revision=revision_id,
354
 
            lossy=lossy, tag_selector=tag_selector)
 
304
                target, overwrite=overwrite, stop_revision=revision_id,
 
305
                lossy=lossy)
355
306
        push_result.new_revid = push_result.branch_push_result.new_revid
356
307
        push_result.old_revid = push_result.branch_push_result.old_revid
357
 
        try:
358
 
            wt = self.open_workingtree()
359
 
        except brz_errors.NoWorkingTree:
360
 
            push_result.workingtree_updated = None
361
 
        else:
362
 
            if self.open_branch(name="").name == target.name:
363
 
                wt._update_git_tree(
364
 
                    old_revision=push_result.old_revid,
365
 
                    new_revision=push_result.new_revid)
366
 
                push_result.workingtree_updated = True
367
 
            else:
368
 
                push_result.workingtree_updated = False
369
 
        push_result.target_branch = target
 
308
        push_result.target_branch = self.open_branch(name)
370
309
        if source.get_push_location() is None or remember:
371
310
            source.set_push_location(push_result.target_branch.base)
372
311
        return push_result
400
339
 
401
340
        """
402
341
        from .transportgit import TransportRepo
403
 
 
404
 
        def _open(transport):
405
 
            try:
406
 
                return TransportRepo(transport, self.bare,
407
 
                                     refs_text=getattr(self, "_refs_text", None))
408
 
            except ValueError as e:
409
 
                if e.args == ('Expected file to start with \'gitdir: \'', ):
410
 
                    raise brz_errors.NotBranchError(path=transport.base)
411
 
                raise
412
 
 
413
 
        def redirected(transport, e, redirection_notice):
414
 
            trace.note(redirection_notice)
415
 
            return transport._redirected_to(e.source, e.target)
416
 
        gitrepo = do_catching_redirections(_open, transport, redirected)
417
 
        if not _found and not gitrepo._controltransport.has('objects'):
418
 
            raise brz_errors.NotBranchError(path=transport.base)
 
342
        gitrepo = TransportRepo(transport, self.bare,
 
343
                refs_text=getattr(self, "_refs_text", None))
 
344
        if not gitrepo._controltransport.has('HEAD'):
 
345
            raise bzr_errors.NotBranchError(path=transport.base)
419
346
        return LocalGitDir(transport, gitrepo, self)
420
347
 
421
348
    def get_format_description(self):
423
350
 
424
351
    def initialize_on_transport(self, transport):
425
352
        from .transportgit import TransportRepo
426
 
        git_repo = TransportRepo.init(transport, bare=self.bare)
427
 
        return LocalGitDir(transport, git_repo, self)
 
353
        repo = TransportRepo.init(transport, bare=self.bare)
 
354
        return self.open(transport)
428
355
 
429
356
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
430
 
                                   create_prefix=False, force_new_repo=False,
431
 
                                   stacked_on=None,
432
 
                                   stack_on_pwd=None, repo_format_name=None,
433
 
                                   make_working_trees=None,
434
 
                                   shared_repo=False, vfs_only=False):
435
 
        if shared_repo:
436
 
            raise brz_errors.SharedRepositoriesUnsupported(self)
437
 
 
 
357
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
358
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
359
        shared_repo=False, vfs_only=False):
438
360
        def make_directory(transport):
439
361
            transport.mkdir('.')
440
362
            return transport
441
 
 
442
363
        def redirected(transport, e, redirection_notice):
443
364
            trace.note(redirection_notice)
444
365
            return transport._redirected_to(e.source, e.target)
445
366
        try:
446
 
            transport = do_catching_redirections(
447
 
                make_directory, transport, redirected)
448
 
        except brz_errors.FileExists:
 
367
            transport = do_catching_redirections(make_directory, transport,
 
368
                redirected)
 
369
        except bzr_errors.FileExists:
449
370
            if not use_existing_dir:
450
371
                raise
451
 
        except brz_errors.NoSuchFile:
 
372
        except bzr_errors.NoSuchFile:
452
373
            if not create_prefix:
453
374
                raise
454
375
            transport.create_prefix()
469
390
    def supports_transport(self, transport):
470
391
        try:
471
392
            external_url = transport.external_url()
472
 
        except brz_errors.InProcessTransport:
473
 
            raise brz_errors.NotBranchError(path=transport.base)
 
393
        except bzr_errors.InProcessTransport:
 
394
            raise bzr_errors.NotBranchError(path=transport.base)
474
395
        return external_url.startswith("file:")
475
396
 
476
 
    def is_control_filename(self, filename):
477
 
        return (filename == '.git'
478
 
                or filename.startswith('.git/')
479
 
                or filename.startswith('.git\\'))
480
 
 
481
397
 
482
398
class BareLocalGitControlDirFormat(LocalGitControlDirFormat):
483
399
 
487
403
    def get_format_description(self):
488
404
        return "Local Git Repository (bare)"
489
405
 
490
 
    def is_control_filename(self, filename):
491
 
        return False
492
 
 
493
406
 
494
407
class LocalGitDir(GitDir):
495
408
    """An adapter to the '.git' dir used by git."""
523
436
            self.transport = transport.clone('.git')
524
437
        self._mode_check_done = None
525
438
 
 
439
    def is_control_filename(self, filename):
 
440
        return (filename == '.git' or
 
441
                filename.startswith('.git/') or
 
442
                filename.startswith('.git\\'))
 
443
 
526
444
    def _get_symref(self, ref):
 
445
        from dulwich.repo import SYMREF
527
446
        ref_chain, unused_sha = self._git.refs.follow(ref)
528
447
        if len(ref_chain) == 1:
529
448
            return None
531
450
 
532
451
    def set_branch_reference(self, target_branch, name=None):
533
452
        ref = self._get_selected_ref(name)
534
 
        target_transport = target_branch.controldir.control_transport
535
 
        if self.control_transport.base == target_transport.base:
 
453
        if self.control_transport.base == target_branch.controldir.control_transport.base:
536
454
            if ref == target_branch.ref:
537
455
                raise BranchReferenceLoop(target_branch)
538
456
            self._git.refs.set_symbolic_ref(ref, target_branch.ref)
539
457
        else:
540
458
            try:
541
 
                target_path = (
542
 
                    target_branch.controldir.control_transport.local_abspath(
543
 
                        '.'))
544
 
            except brz_errors.NotLocalUrl:
545
 
                raise brz_errors.IncompatibleFormat(
546
 
                    target_branch._format, self._format)
 
459
                target_path = target_branch.controldir.control_transport.local_abspath('.')
 
460
            except bzr_errors.NotLocalUrl:
 
461
                raise bzr_errors.IncompatibleFormat(target_branch._format, self._format)
547
462
            # TODO(jelmer): Do some consistency checking across branches..
548
 
            self.control_transport.put_bytes(
549
 
                'commondir', encode_git_path(target_path))
 
463
            self.control_transport.put_bytes('commondir', target_path.encode('utf-8'))
550
464
            # TODO(jelmer): Urgh, avoid mucking about with internals.
551
 
            self._git._commontransport = (
552
 
                target_branch.repository._git._commontransport.clone())
553
 
            self._git.object_store = TransportObjectStore(
554
 
                self._git._commontransport.clone(OBJECTDIR))
 
465
            self._git._commontransport = target_branch.repository._git._commontransport.clone()
 
466
            self._git.object_store = TransportObjectStore(self._git._commontransport.clone(OBJECTDIR))
555
467
            self._git.refs.transport = self._git._commontransport
556
 
            target_ref_chain, unused_sha = (
557
 
                target_branch.controldir._git.refs.follow(target_branch.ref))
 
468
            target_ref_chain, unused_sha = target_branch.controldir._git.refs.follow(target_branch.ref)
558
469
            for target_ref in target_ref_chain:
559
470
                if target_ref == b'HEAD':
560
471
                    continue
561
472
                break
562
473
            else:
563
474
                # Can't create a reference to something that is not a in a repository.
564
 
                raise brz_errors.IncompatibleFormat(
565
 
                    self.set_branch_reference, self)
 
475
                raise bzr_errors.IncompatibleFormat(self.set_branch_reference, self)
566
476
            self._git.refs.set_symbolic_ref(ref, target_ref)
567
477
 
568
478
    def get_branch_reference(self, name=None):
573
483
            try:
574
484
                branch_name = ref_to_branch_name(target_ref)
575
485
            except ValueError:
576
 
                params = {'ref': urlutils.quote(
577
 
                    target_ref.decode('utf-8'), '')}
 
486
                params = {'ref': urllib.quote(target_ref, '')}
578
487
            else:
579
 
                if branch_name != '':
580
 
                    params = {'branch': urlutils.quote(branch_name, '')}
 
488
                if branch_name != b'':
 
489
                    params = {'branch': urllib.quote(branch_name.encode('utf-8'), '')}
581
490
                else:
582
491
                    params = {}
583
492
            try:
584
 
                commondir = self.control_transport.get_bytes('commondir')
585
 
            except brz_errors.NoSuchFile:
 
493
                base_url = urlutils.local_path_to_url(self.control_transport.get_bytes('commondir')).rstrip('/.git/')+'/'
 
494
            except bzr_errors.NoSuchFile:
586
495
                base_url = self.user_url.rstrip('/')
587
 
            else:
588
 
                base_url = urlutils.local_path_to_url(
589
 
                    decode_git_path(commondir)).rstrip('/.git/') + '/'
590
496
            return urlutils.join_segment_parameters(base_url, params)
591
497
        return None
592
498
 
594
500
        from .branch import (
595
501
            LocalGitBranchFormat,
596
502
            )
 
503
        ref = self._get_selected_ref(name)
597
504
        return LocalGitBranchFormat()
598
505
 
599
506
    def get_branch_transport(self, branch_format, name=None):
601
508
            return self.transport
602
509
        if isinstance(branch_format, LocalGitControlDirFormat):
603
510
            return self.transport
604
 
        raise brz_errors.IncompatibleFormat(branch_format, self._format)
 
511
        raise bzr_errors.IncompatibleFormat(branch_format, self._format)
605
512
 
606
513
    def get_repository_transport(self, format):
607
514
        if format is None:
608
515
            return self.transport
609
516
        if isinstance(format, LocalGitControlDirFormat):
610
517
            return self.transport
611
 
        raise brz_errors.IncompatibleFormat(format, self._format)
 
518
        raise bzr_errors.IncompatibleFormat(format, self._format)
612
519
 
613
520
    def get_workingtree_transport(self, format):
614
521
        if format is None:
615
522
            return self.transport
616
523
        if isinstance(format, LocalGitControlDirFormat):
617
524
            return self.transport
618
 
        raise brz_errors.IncompatibleFormat(format, self._format)
 
525
        raise bzr_errors.IncompatibleFormat(format, self._format)
619
526
 
620
527
    def open_branch(self, name=None, unsupported=False, ignore_fallbacks=None,
621
 
                    ref=None, possible_transports=None, nascent_ok=False):
 
528
            ref=None, possible_transports=None, nascent_ok=False):
622
529
        """'create' a branch for this dir."""
623
530
        repo = self.find_repository()
624
531
        from .branch import LocalGitBranch
625
532
        ref = self._get_selected_ref(name, ref)
626
533
        if not nascent_ok and ref not in self._git.refs:
627
 
            raise brz_errors.NotBranchError(
628
 
                self.root_transport.base, controldir=self)
 
534
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
535
                    controldir=self)
629
536
        ref_chain, unused_sha = self._git.refs.follow(ref)
630
537
        if ref_chain[-1] == b'HEAD':
631
538
            controldir = self
637
544
        refname = self._get_selected_ref(name)
638
545
        if refname == b'HEAD':
639
546
            # HEAD can't be removed
640
 
            raise brz_errors.UnsupportedOperation(
 
547
            raise bzr_errors.UnsupportedOperation(
641
548
                self.destroy_branch, self)
642
549
        try:
643
550
            del self._git.refs[refname]
644
551
        except KeyError:
645
 
            raise brz_errors.NotBranchError(
646
 
                self.root_transport.base, controldir=self)
 
552
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
553
                    controldir=self)
647
554
 
648
555
    def destroy_repository(self):
649
 
        raise brz_errors.UnsupportedOperation(self.destroy_repository, self)
 
556
        raise bzr_errors.UnsupportedOperation(self.destroy_repository, self)
650
557
 
651
558
    def destroy_workingtree(self):
652
 
        raise brz_errors.UnsupportedOperation(self.destroy_workingtree, self)
 
559
        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree, self)
653
560
 
654
561
    def destroy_workingtree_metadata(self):
655
 
        raise brz_errors.UnsupportedOperation(
656
 
            self.destroy_workingtree_metadata, self)
 
562
        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree_metadata, self)
657
563
 
658
564
    def needs_format_conversion(self, format=None):
659
565
        return not isinstance(self._format, format.__class__)
661
567
    def open_repository(self):
662
568
        """'open' a repository for this dir."""
663
569
        if self.control_transport.has('commondir'):
664
 
            raise brz_errors.NoRepositoryPresent(self)
 
570
            raise bzr_errors.NoRepositoryPresent(self)
665
571
        return self._gitrepository_class(self)
666
572
 
667
573
    def has_workingtree(self):
669
575
 
670
576
    def open_workingtree(self, recommend_upgrade=True, unsupported=False):
671
577
        if not self._git.bare:
 
578
            from dulwich.errors import NoIndexPresent
672
579
            repo = self.find_repository()
673
580
            from .workingtree import GitWorkingTree
674
581
            branch = self.open_branch(ref=b'HEAD', nascent_ok=True)
675
582
            return GitWorkingTree(self, repo, branch)
676
583
        loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
677
 
        raise brz_errors.NoWorkingTree(loc)
 
584
        raise bzr_errors.NoWorkingTree(loc)
678
585
 
679
586
    def create_repository(self, shared=False):
680
587
        from .repository import GitRepositoryFormat
681
588
        if shared:
682
 
            raise brz_errors.IncompatibleFormat(
683
 
                GitRepositoryFormat(), self._format)
 
589
            raise bzr_errors.IncompatibleFormat(GitRepositoryFormat(), self._format)
684
590
        return self.find_repository()
685
591
 
686
592
    def create_branch(self, name=None, repository=None,
687
593
                      append_revisions_only=None, ref=None):
688
594
        refname = self._get_selected_ref(name, ref)
689
595
        if refname != b'HEAD' and refname in self._git.refs:
690
 
            raise brz_errors.AlreadyBranchError(self.user_url)
 
596
            raise bzr_errors.AlreadyBranchError(self.user_url)
691
597
        repo = self.open_repository()
692
598
        if refname in self._git.refs:
693
 
            ref_chain, unused_sha = self._git.refs.follow(
694
 
                self._get_selected_ref(None))
 
599
            ref_chain, unused_sha = self._git.refs.follow(self._get_selected_ref(None))
695
600
            if ref_chain[0] == b'HEAD':
696
601
                refname = ref_chain[1]
697
602
        from .branch import LocalGitBranch
711
616
            parent.copy_tree(basename, basename + ".backup")
712
617
 
713
618
    def create_workingtree(self, revision_id=None, from_branch=None,
714
 
                           accelerator_tree=None, hardlink=False):
 
619
        accelerator_tree=None, hardlink=False):
715
620
        if self._git.bare:
716
 
            raise brz_errors.UnsupportedOperation(
717
 
                self.create_workingtree, self)
 
621
            raise bzr_errors.UnsupportedOperation(self.create_workingtree, self)
718
622
        if from_branch is None:
719
623
            from_branch = self.open_branch(nascent_ok=True)
720
624
        if revision_id is None:
742
646
        self._mode_check_done = True
743
647
        try:
744
648
            st = self.transport.stat('.')
745
 
        except brz_errors.TransportNotPossible:
 
649
        except bzr_errors.TransportNotPossible:
746
650
            self._dir_mode = None
747
651
            self._file_mode = None
748
652
        else:
782
686
    def _find_commondir(self):
783
687
        try:
784
688
            commondir = self.control_transport.get_bytes('commondir')
785
 
        except brz_errors.NoSuchFile:
 
689
        except bzr_errors.NoSuchFile:
786
690
            return self
787
691
        else:
788
 
            commondir = commondir.rstrip(b'/.git/').decode(osutils._fs_enc)
789
 
            return ControlDir.open_from_transport(
790
 
                get_transport_from_path(commondir))
 
692
            commondir = commondir.rstrip('/.git/')
 
693
            return ControlDir.open_from_transport(get_transport_from_path(commondir))