/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-09-11 01:42:58 UTC
  • mfrom: (7078.14.1 selftest-traceback)
  • Revision ID: breezy.the.bot@gmail.com-20180911014258-uz6zjh6m552knqfv
Don't rely on self._traceback_from_test as it gets set too late on Python 3 unittest.TestCase.

Merged from https://code.launchpad.net/~jelmer/brz/selftest-traceback/+merge/353737

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2007 Canonical Ltd
 
2
# Copyright (C) 2010-2018 Jelmer Vernooij
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
 
 
18
"""An adapter between a Git control dir and a Bazaar ControlDir."""
 
19
 
 
20
from __future__ import absolute_import
 
21
 
 
22
from .. import (
 
23
    branch as _mod_branch,
 
24
    errors as bzr_errors,
 
25
    trace,
 
26
    osutils,
 
27
    repository as _mod_repository,
 
28
    revision as _mod_revision,
 
29
    urlutils,
 
30
    )
 
31
from ..sixish import (
 
32
    PY3,
 
33
    viewitems,
 
34
    )
 
35
from ..transport import (
 
36
    do_catching_redirections,
 
37
    get_transport_from_path,
 
38
    )
 
39
 
 
40
from ..controldir import (
 
41
    BranchReferenceLoop,
 
42
    ControlDir,
 
43
    ControlDirFormat,
 
44
    format_registry,
 
45
    RepositoryAcquisitionPolicy,
 
46
    )
 
47
from .object_store import (
 
48
    get_object_store,
 
49
    )
 
50
 
 
51
from .push import (
 
52
    GitPushResult,
 
53
    )
 
54
from .transportgit import (
 
55
    OBJECTDIR,
 
56
    TransportObjectStore,
 
57
    )
 
58
 
 
59
 
 
60
class GitDirConfig(object):
 
61
 
 
62
    def get_default_stack_on(self):
 
63
        return None
 
64
 
 
65
    def set_default_stack_on(self, value):
 
66
        raise bzr_errors.BzrError("Cannot set configuration")
 
67
 
 
68
 
 
69
class GitControlDirFormat(ControlDirFormat):
 
70
 
 
71
    colocated_branches = True
 
72
    fixed_components = True
 
73
 
 
74
    def __eq__(self, other):
 
75
        return type(self) == type(other)
 
76
 
 
77
    def is_supported(self):
 
78
        return True
 
79
 
 
80
    def network_name(self):
 
81
        return b"git"
 
82
 
 
83
 
 
84
class UseExistingRepository(RepositoryAcquisitionPolicy):
 
85
    """A policy of reusing an existing repository"""
 
86
 
 
87
    def __init__(self, repository, stack_on=None, stack_on_pwd=None,
 
88
                 require_stacking=False):
 
89
        """Constructor.
 
90
 
 
91
        :param repository: The repository to use.
 
92
        :param stack_on: A location to stack on
 
93
        :param stack_on_pwd: If stack_on is relative, the location it is
 
94
            relative to.
 
95
        """
 
96
        super(UseExistingRepository, self).__init__(
 
97
                stack_on, stack_on_pwd, require_stacking)
 
98
        self._repository = repository
 
99
 
 
100
    def acquire_repository(self, make_working_trees=None, shared=False,
 
101
            possible_transports=None):
 
102
        """Implementation of RepositoryAcquisitionPolicy.acquire_repository
 
103
 
 
104
        Returns an existing repository to use.
 
105
        """
 
106
        return self._repository, False
 
107
 
 
108
 
 
109
class GitDir(ControlDir):
 
110
    """An adapter to the '.git' dir used by git."""
 
111
 
 
112
    def is_supported(self):
 
113
        return True
 
114
 
 
115
    def can_convert_format(self):
 
116
        return False
 
117
 
 
118
    def break_lock(self):
 
119
        # There are no global locks, so nothing to break.
 
120
        raise NotImplementedError(self.break_lock)
 
121
 
 
122
    def cloning_metadir(self, stacked=False):
 
123
        return format_registry.make_controldir("git")
 
124
 
 
125
    def checkout_metadir(self, stacked=False):
 
126
        return format_registry.make_controldir("git")
 
127
 
 
128
    def _get_selected_ref(self, branch, ref=None):
 
129
        if ref is not None and branch is not None:
 
130
            raise bzr_errors.BzrError("can't specify both ref and branch")
 
131
        if ref is not None:
 
132
            return ref
 
133
        if branch is not None:
 
134
            from .refs import branch_name_to_ref
 
135
            return branch_name_to_ref(branch)
 
136
        segment_parameters = getattr(
 
137
            self.user_transport, "get_segment_parameters", lambda: {})()
 
138
        ref = segment_parameters.get("ref")
 
139
        if ref is not None:
 
140
            return urlutils.unquote_to_bytes(ref)
 
141
        if branch is None and getattr(self, "_get_selected_branch", False):
 
142
            branch = self._get_selected_branch()
 
143
            if branch is not None:
 
144
                from .refs import branch_name_to_ref
 
145
                return branch_name_to_ref(branch)
 
146
        return b"HEAD"
 
147
 
 
148
    def get_config(self):
 
149
        return GitDirConfig()
 
150
 
 
151
    def _available_backup_name(self, base):
 
152
        return osutils.available_backup_name(base, self.root_transport.has)
 
153
 
 
154
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
155
               recurse='down', possible_transports=None,
 
156
               accelerator_tree=None, hardlink=False, stacked=False,
 
157
               source_branch=None, create_tree_if_local=True):
 
158
        from ..repository import InterRepository
 
159
        from ..transport.local import LocalTransport
 
160
        from ..transport import get_transport
 
161
        target_transport = get_transport(url, possible_transports)
 
162
        target_transport.ensure_base()
 
163
        cloning_format = self.cloning_metadir()
 
164
        # Create/update the result branch
 
165
        try:
 
166
            result = ControlDir.open_from_transport(target_transport)
 
167
        except bzr_errors.NotBranchError:
 
168
            result = cloning_format.initialize_on_transport(target_transport)
 
169
        source_branch = self.open_branch()
 
170
        source_repository = self.find_repository()
 
171
        try:
 
172
            result_repo = result.find_repository()
 
173
        except bzr_errors.NoRepositoryPresent:
 
174
            result_repo = result.create_repository()
 
175
            target_is_empty = True
 
176
        else:
 
177
            target_is_empty = None # Unknown
 
178
        if stacked:
 
179
            raise _mod_branch.UnstackableBranchFormat(self._format, self.user_url)
 
180
        interrepo = InterRepository.get(source_repository, result_repo)
 
181
 
 
182
        if revision_id is not None:
 
183
            determine_wants = interrepo.get_determine_wants_revids(
 
184
                [revision_id], include_tags=True)
 
185
        else:
 
186
            determine_wants = interrepo.determine_wants_all
 
187
        interrepo.fetch_objects(determine_wants=determine_wants,
 
188
            mapping=source_branch.mapping)
 
189
        result_branch = source_branch.sprout(result,
 
190
            revision_id=revision_id, repository=result_repo)
 
191
        if (create_tree_if_local
 
192
            and isinstance(target_transport, LocalTransport)
 
193
            and (result_repo is None or result_repo.make_working_trees())):
 
194
            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
 
195
                hardlink=hardlink, from_branch=result_branch)
 
196
        return result
 
197
 
 
198
    def clone_on_transport(self, transport, revision_id=None,
 
199
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
 
200
        create_prefix=False, use_existing_dir=True, no_tree=False):
 
201
        """See ControlDir.clone_on_transport."""
 
202
        from ..repository import InterRepository
 
203
        from .mapping import default_mapping
 
204
        if stacked_on is not None:
 
205
            raise _mod_branch.UnstackableBranchFormat(self._format, self.user_url)
 
206
        if no_tree:
 
207
            format = BareLocalGitControlDirFormat()
 
208
        else:
 
209
            format = LocalGitControlDirFormat()
 
210
        (target_repo, target_controldir, stacking,
 
211
                repo_policy) = format.initialize_on_transport_ex(
 
212
                        transport, use_existing_dir=use_existing_dir,
 
213
                        create_prefix=create_prefix,
 
214
                        force_new_repo=force_new_repo)
 
215
        target_repo = target_controldir.find_repository()
 
216
        target_git_repo = target_repo._git
 
217
        source_repo = self.find_repository()
 
218
        source_git_repo = source_repo._git
 
219
        interrepo = InterRepository.get(source_repo, target_repo)
 
220
        if revision_id is not None:
 
221
            determine_wants = interrepo.get_determine_wants_revids([revision_id], include_tags=True)
 
222
        else:
 
223
            determine_wants = interrepo.determine_wants_all
 
224
        (pack_hint, _, refs) = interrepo.fetch_objects(determine_wants,
 
225
            mapping=default_mapping)
 
226
        for name, val in viewitems(refs):
 
227
            target_git_repo.refs[name] = val
 
228
        result_dir = self.__class__(transport, target_git_repo, format)
 
229
        if revision_id is not None:
 
230
            result_dir.open_branch().set_last_revision(revision_id)
 
231
        try:
 
232
            # Cheaper to check if the target is not local, than to try making
 
233
            # the tree and fail.
 
234
            result_dir.root_transport.local_abspath('.')
 
235
            if result_dir.open_repository().make_working_trees():
 
236
                self.open_workingtree().clone(result_dir, revision_id=revision_id)
 
237
        except (bzr_errors.NoWorkingTree, bzr_errors.NotLocalUrl):
 
238
            pass
 
239
 
 
240
        return result_dir
 
241
 
 
242
    def find_repository(self):
 
243
        """Find the repository that should be used.
 
244
 
 
245
        This does not require a branch as we use it to find the repo for
 
246
        new branches as well as to hook existing branches up to their
 
247
        repository.
 
248
        """
 
249
        return self._gitrepository_class(self._find_commondir())
 
250
 
 
251
    def get_refs_container(self):
 
252
        """Retrieve the refs container.
 
253
        """
 
254
        raise NotImplementedError(self.get_refs_container)
 
255
 
 
256
    def determine_repository_policy(self, force_new_repo=False, stack_on=None,
 
257
                                    stack_on_pwd=None, require_stacking=False):
 
258
        """Return an object representing a policy to use.
 
259
 
 
260
        This controls whether a new repository is created, and the format of
 
261
        that repository, or some existing shared repository used instead.
 
262
 
 
263
        If stack_on is supplied, will not seek a containing shared repo.
 
264
 
 
265
        :param force_new_repo: If True, require a new repository to be created.
 
266
        :param stack_on: If supplied, the location to stack on.  If not
 
267
            supplied, a default_stack_on location may be used.
 
268
        :param stack_on_pwd: If stack_on is relative, the location it is
 
269
            relative to.
 
270
        """
 
271
        return UseExistingRepository(self.find_repository())
 
272
 
 
273
    def get_branches(self):
 
274
        from .refs import ref_to_branch_name
 
275
        ret = {}
 
276
        for ref in self.get_refs_container().keys():
 
277
            try:
 
278
                branch_name = ref_to_branch_name(ref)
 
279
            except ValueError:
 
280
                continue
 
281
            except UnicodeDecodeError:
 
282
                trace.warning("Ignoring branch %r with unicode error ref", ref)
 
283
                continue
 
284
            ret[branch_name] = self.open_branch(ref=ref)
 
285
        return ret
 
286
 
 
287
    def list_branches(self):
 
288
        return list(self.get_branches().values())
 
289
 
 
290
    def push_branch(self, source, revision_id=None, overwrite=False,
 
291
                    remember=False, create_prefix=False, lossy=False,
 
292
                    name=None):
 
293
        """Push the source branch into this ControlDir."""
 
294
        push_result = GitPushResult()
 
295
        push_result.workingtree_updated = None
 
296
        push_result.master_branch = None
 
297
        push_result.source_branch = source
 
298
        push_result.stacked_on = None
 
299
        repo = self.find_repository()
 
300
        refname = self._get_selected_ref(name)
 
301
        from .branch import GitBranch
 
302
        if isinstance(source, GitBranch) and lossy:
 
303
            raise bzr_errors.LossyPushToSameVCS(source.controldir, self)
 
304
        target = self.open_branch(name, nascent_ok=True)
 
305
        push_result.branch_push_result = source.push(
 
306
                target, overwrite=overwrite, stop_revision=revision_id,
 
307
                lossy=lossy)
 
308
        push_result.new_revid = push_result.branch_push_result.new_revid
 
309
        push_result.old_revid = push_result.branch_push_result.old_revid
 
310
        push_result.target_branch = self.open_branch(name)
 
311
        if source.get_push_location() is None or remember:
 
312
            source.set_push_location(push_result.target_branch.base)
 
313
        return push_result
 
314
 
 
315
 
 
316
class LocalGitControlDirFormat(GitControlDirFormat):
 
317
    """The .git directory control format."""
 
318
 
 
319
    bare = False
 
320
 
 
321
    @classmethod
 
322
    def _known_formats(self):
 
323
        return set([LocalGitControlDirFormat()])
 
324
 
 
325
    @property
 
326
    def repository_format(self):
 
327
        from .repository import GitRepositoryFormat
 
328
        return GitRepositoryFormat()
 
329
 
 
330
    @property
 
331
    def workingtree_format(self):
 
332
        from .workingtree import GitWorkingTreeFormat
 
333
        return GitWorkingTreeFormat()
 
334
 
 
335
    def get_branch_format(self):
 
336
        from .branch import LocalGitBranchFormat
 
337
        return LocalGitBranchFormat()
 
338
 
 
339
    def open(self, transport, _found=None):
 
340
        """Open this directory.
 
341
 
 
342
        """
 
343
        from .transportgit import TransportRepo
 
344
        gitrepo = TransportRepo(transport, self.bare,
 
345
                refs_text=getattr(self, "_refs_text", None))
 
346
        if not gitrepo._controltransport.has('HEAD'):
 
347
            raise bzr_errors.NotBranchError(path=transport.base)
 
348
        return LocalGitDir(transport, gitrepo, self)
 
349
 
 
350
    def get_format_description(self):
 
351
        return "Local Git Repository"
 
352
 
 
353
    def initialize_on_transport(self, transport):
 
354
        from .transportgit import TransportRepo
 
355
        repo = TransportRepo.init(transport, bare=self.bare)
 
356
        return self.open(transport)
 
357
 
 
358
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
359
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
360
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
361
        shared_repo=False, vfs_only=False):
 
362
        def make_directory(transport):
 
363
            transport.mkdir('.')
 
364
            return transport
 
365
        def redirected(transport, e, redirection_notice):
 
366
            trace.note(redirection_notice)
 
367
            return transport._redirected_to(e.source, e.target)
 
368
        try:
 
369
            transport = do_catching_redirections(make_directory, transport,
 
370
                redirected)
 
371
        except bzr_errors.FileExists:
 
372
            if not use_existing_dir:
 
373
                raise
 
374
        except bzr_errors.NoSuchFile:
 
375
            if not create_prefix:
 
376
                raise
 
377
            transport.create_prefix()
 
378
        controldir = self.initialize_on_transport(transport)
 
379
        if repo_format_name:
 
380
            result_repo = controldir.find_repository()
 
381
            repository_policy = UseExistingRepository(result_repo)
 
382
            result_repo.lock_write()
 
383
        else:
 
384
            result_repo = None
 
385
            repository_policy = None
 
386
        return (result_repo, controldir, False,
 
387
                repository_policy)
 
388
 
 
389
    def is_supported(self):
 
390
        return True
 
391
 
 
392
    def supports_transport(self, transport):
 
393
        try:
 
394
            external_url = transport.external_url()
 
395
        except bzr_errors.InProcessTransport:
 
396
            raise bzr_errors.NotBranchError(path=transport.base)
 
397
        return external_url.startswith("file:")
 
398
 
 
399
 
 
400
class BareLocalGitControlDirFormat(LocalGitControlDirFormat):
 
401
 
 
402
    bare = True
 
403
    supports_workingtrees = False
 
404
 
 
405
    def get_format_description(self):
 
406
        return "Local Git Repository (bare)"
 
407
 
 
408
 
 
409
class LocalGitDir(GitDir):
 
410
    """An adapter to the '.git' dir used by git."""
 
411
 
 
412
    def _get_gitrepository_class(self):
 
413
        from .repository import LocalGitRepository
 
414
        return LocalGitRepository
 
415
 
 
416
    def __repr__(self):
 
417
        return "<%s at %r>" % (
 
418
            self.__class__.__name__, self.root_transport.base)
 
419
 
 
420
    _gitrepository_class = property(_get_gitrepository_class)
 
421
 
 
422
    @property
 
423
    def user_transport(self):
 
424
        return self.root_transport
 
425
 
 
426
    @property
 
427
    def control_transport(self):
 
428
        return self._git._controltransport
 
429
 
 
430
    def __init__(self, transport, gitrepo, format):
 
431
        self._format = format
 
432
        self.root_transport = transport
 
433
        self._mode_check_done = False
 
434
        self._git = gitrepo
 
435
        if gitrepo.bare:
 
436
            self.transport = transport
 
437
        else:
 
438
            self.transport = transport.clone('.git')
 
439
        self._mode_check_done = None
 
440
 
 
441
    def is_control_filename(self, filename):
 
442
        return (filename == '.git' or
 
443
                filename.startswith('.git/') or
 
444
                filename.startswith('.git\\'))
 
445
 
 
446
    def _get_symref(self, ref):
 
447
        from dulwich.repo import SYMREF
 
448
        ref_chain, unused_sha = self._git.refs.follow(ref)
 
449
        if len(ref_chain) == 1:
 
450
            return None
 
451
        return ref_chain[1]
 
452
 
 
453
    def set_branch_reference(self, target_branch, name=None):
 
454
        ref = self._get_selected_ref(name)
 
455
        if self.control_transport.base == target_branch.controldir.control_transport.base:
 
456
            if ref == target_branch.ref:
 
457
                raise BranchReferenceLoop(target_branch)
 
458
            self._git.refs.set_symbolic_ref(ref, target_branch.ref)
 
459
        else:
 
460
            try:
 
461
                target_path = target_branch.controldir.control_transport.local_abspath('.')
 
462
            except bzr_errors.NotLocalUrl:
 
463
                raise bzr_errors.IncompatibleFormat(target_branch._format, self._format)
 
464
            # TODO(jelmer): Do some consistency checking across branches..
 
465
            self.control_transport.put_bytes('commondir', target_path.encode('utf-8'))
 
466
            # TODO(jelmer): Urgh, avoid mucking about with internals.
 
467
            self._git._commontransport = target_branch.repository._git._commontransport.clone()
 
468
            self._git.object_store = TransportObjectStore(self._git._commontransport.clone(OBJECTDIR))
 
469
            self._git.refs.transport = self._git._commontransport
 
470
            target_ref_chain, unused_sha = target_branch.controldir._git.refs.follow(target_branch.ref)
 
471
            for target_ref in target_ref_chain:
 
472
                if target_ref == b'HEAD':
 
473
                    continue
 
474
                break
 
475
            else:
 
476
                # Can't create a reference to something that is not a in a repository.
 
477
                raise bzr_errors.IncompatibleFormat(self.set_branch_reference, self)
 
478
            self._git.refs.set_symbolic_ref(ref, target_ref)
 
479
 
 
480
    def get_branch_reference(self, name=None):
 
481
        ref = self._get_selected_ref(name)
 
482
        target_ref = self._get_symref(ref)
 
483
        if target_ref is not None:
 
484
            from .refs import ref_to_branch_name
 
485
            try:
 
486
                branch_name = ref_to_branch_name(target_ref)
 
487
            except ValueError:
 
488
                params = {'ref': urlutils.quote(target_ref.decode('utf-8'), '')}
 
489
            else:
 
490
                if branch_name != '':
 
491
                    params = {'branch': urlutils.quote(branch_name, '')}
 
492
                else:
 
493
                    params = {}
 
494
            try:
 
495
                commondir = self.control_transport.get_bytes('commondir')
 
496
            except bzr_errors.NoSuchFile:
 
497
                base_url = self.user_url.rstrip('/')
 
498
            else:
 
499
                base_url = urlutils.local_path_to_url(commondir.decode(osutils._fs_enc)).rstrip('/.git/')+'/'
 
500
            if not PY3:
 
501
                params = {k: v.encode('utf-8') for (k, v) in viewitems(params)}
 
502
            return urlutils.join_segment_parameters(base_url, params)
 
503
        return None
 
504
 
 
505
    def find_branch_format(self, name=None):
 
506
        from .branch import (
 
507
            LocalGitBranchFormat,
 
508
            )
 
509
        ref = self._get_selected_ref(name)
 
510
        return LocalGitBranchFormat()
 
511
 
 
512
    def get_branch_transport(self, branch_format, name=None):
 
513
        if branch_format is None:
 
514
            return self.transport
 
515
        if isinstance(branch_format, LocalGitControlDirFormat):
 
516
            return self.transport
 
517
        raise bzr_errors.IncompatibleFormat(branch_format, self._format)
 
518
 
 
519
    def get_repository_transport(self, format):
 
520
        if format is None:
 
521
            return self.transport
 
522
        if isinstance(format, LocalGitControlDirFormat):
 
523
            return self.transport
 
524
        raise bzr_errors.IncompatibleFormat(format, self._format)
 
525
 
 
526
    def get_workingtree_transport(self, format):
 
527
        if format is None:
 
528
            return self.transport
 
529
        if isinstance(format, LocalGitControlDirFormat):
 
530
            return self.transport
 
531
        raise bzr_errors.IncompatibleFormat(format, self._format)
 
532
 
 
533
    def open_branch(self, name=None, unsupported=False, ignore_fallbacks=None,
 
534
            ref=None, possible_transports=None, nascent_ok=False):
 
535
        """'create' a branch for this dir."""
 
536
        repo = self.find_repository()
 
537
        from .branch import LocalGitBranch
 
538
        ref = self._get_selected_ref(name, ref)
 
539
        if not nascent_ok and ref not in self._git.refs:
 
540
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
541
                    controldir=self)
 
542
        ref_chain, unused_sha = self._git.refs.follow(ref)
 
543
        if ref_chain[-1] == b'HEAD':
 
544
            controldir = self
 
545
        else:
 
546
            controldir = self._find_commondir()
 
547
        return LocalGitBranch(controldir, repo, ref_chain[-1])
 
548
 
 
549
    def destroy_branch(self, name=None):
 
550
        refname = self._get_selected_ref(name)
 
551
        if refname == b'HEAD':
 
552
            # HEAD can't be removed
 
553
            raise bzr_errors.UnsupportedOperation(
 
554
                self.destroy_branch, self)
 
555
        try:
 
556
            del self._git.refs[refname]
 
557
        except KeyError:
 
558
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
559
                    controldir=self)
 
560
 
 
561
    def destroy_repository(self):
 
562
        raise bzr_errors.UnsupportedOperation(self.destroy_repository, self)
 
563
 
 
564
    def destroy_workingtree(self):
 
565
        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree, self)
 
566
 
 
567
    def destroy_workingtree_metadata(self):
 
568
        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree_metadata, self)
 
569
 
 
570
    def needs_format_conversion(self, format=None):
 
571
        return not isinstance(self._format, format.__class__)
 
572
 
 
573
    def open_repository(self):
 
574
        """'open' a repository for this dir."""
 
575
        if self.control_transport.has('commondir'):
 
576
            raise bzr_errors.NoRepositoryPresent(self)
 
577
        return self._gitrepository_class(self)
 
578
 
 
579
    def has_workingtree(self):
 
580
        return not self._git.bare
 
581
 
 
582
    def open_workingtree(self, recommend_upgrade=True, unsupported=False):
 
583
        if not self._git.bare:
 
584
            from dulwich.errors import NoIndexPresent
 
585
            repo = self.find_repository()
 
586
            from .workingtree import GitWorkingTree
 
587
            branch = self.open_branch(ref=b'HEAD', nascent_ok=True)
 
588
            return GitWorkingTree(self, repo, branch)
 
589
        loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
 
590
        raise bzr_errors.NoWorkingTree(loc)
 
591
 
 
592
    def create_repository(self, shared=False):
 
593
        from .repository import GitRepositoryFormat
 
594
        if shared:
 
595
            raise bzr_errors.IncompatibleFormat(GitRepositoryFormat(), self._format)
 
596
        return self.find_repository()
 
597
 
 
598
    def create_branch(self, name=None, repository=None,
 
599
                      append_revisions_only=None, ref=None):
 
600
        refname = self._get_selected_ref(name, ref)
 
601
        if refname != b'HEAD' and refname in self._git.refs:
 
602
            raise bzr_errors.AlreadyBranchError(self.user_url)
 
603
        repo = self.open_repository()
 
604
        if refname in self._git.refs:
 
605
            ref_chain, unused_sha = self._git.refs.follow(self._get_selected_ref(None))
 
606
            if ref_chain[0] == b'HEAD':
 
607
                refname = ref_chain[1]
 
608
        from .branch import LocalGitBranch
 
609
        branch = LocalGitBranch(self, repo, refname)
 
610
        if append_revisions_only:
 
611
            branch.set_append_revisions_only(append_revisions_only)
 
612
        return branch
 
613
 
 
614
    def backup_bzrdir(self):
 
615
        if not self._git.bare:
 
616
            self.root_transport.copy_tree(".git", ".git.backup")
 
617
            return (self.root_transport.abspath(".git"),
 
618
                    self.root_transport.abspath(".git.backup"))
 
619
        else:
 
620
            basename = urlutils.basename(self.root_transport.base)
 
621
            parent = self.root_transport.clone('..')
 
622
            parent.copy_tree(basename, basename + ".backup")
 
623
 
 
624
    def create_workingtree(self, revision_id=None, from_branch=None,
 
625
        accelerator_tree=None, hardlink=False):
 
626
        if self._git.bare:
 
627
            raise bzr_errors.UnsupportedOperation(self.create_workingtree, self)
 
628
        if from_branch is None:
 
629
            from_branch = self.open_branch(nascent_ok=True)
 
630
        if revision_id is None:
 
631
            revision_id = from_branch.last_revision()
 
632
        repo = self.find_repository()
 
633
        from .workingtree import GitWorkingTree
 
634
        wt = GitWorkingTree(self, repo, from_branch)
 
635
        wt.set_last_revision(revision_id)
 
636
        wt._build_checkout_with_index()
 
637
        return wt
 
638
 
 
639
    def _find_or_create_repository(self, force_new_repo=None):
 
640
        return self.create_repository(shared=False)
 
641
 
 
642
    def _find_creation_modes(self):
 
643
        """Determine the appropriate modes for files and directories.
 
644
 
 
645
        They're always set to be consistent with the base directory,
 
646
        assuming that this transport allows setting modes.
 
647
        """
 
648
        # TODO: Do we need or want an option (maybe a config setting) to turn
 
649
        # this off or override it for particular locations? -- mbp 20080512
 
650
        if self._mode_check_done:
 
651
            return
 
652
        self._mode_check_done = True
 
653
        try:
 
654
            st = self.transport.stat('.')
 
655
        except bzr_errors.TransportNotPossible:
 
656
            self._dir_mode = None
 
657
            self._file_mode = None
 
658
        else:
 
659
            # Check the directory mode, but also make sure the created
 
660
            # directories and files are read-write for this user. This is
 
661
            # mostly a workaround for filesystems which lie about being able to
 
662
            # write to a directory (cygwin & win32)
 
663
            if (st.st_mode & 0o7777 == 0o0000):
 
664
                # FTP allows stat but does not return dir/file modes
 
665
                self._dir_mode = None
 
666
                self._file_mode = None
 
667
            else:
 
668
                self._dir_mode = (st.st_mode & 0o7777) | 0o0700
 
669
                # Remove the sticky and execute bits for files
 
670
                self._file_mode = self._dir_mode & ~0o7111
 
671
 
 
672
    def _get_file_mode(self):
 
673
        """Return Unix mode for newly created files, or None.
 
674
        """
 
675
        if not self._mode_check_done:
 
676
            self._find_creation_modes()
 
677
        return self._file_mode
 
678
 
 
679
    def _get_dir_mode(self):
 
680
        """Return Unix mode for newly created directories, or None.
 
681
        """
 
682
        if not self._mode_check_done:
 
683
            self._find_creation_modes()
 
684
        return self._dir_mode
 
685
 
 
686
    def get_refs_container(self):
 
687
        return self._git.refs
 
688
 
 
689
    def get_peeled(self, ref):
 
690
        return self._git.get_peeled(ref)
 
691
 
 
692
    def _find_commondir(self):
 
693
        try:
 
694
            commondir = self.control_transport.get_bytes('commondir')
 
695
        except bzr_errors.NoSuchFile:
 
696
            return self
 
697
        else:
 
698
            commondir = commondir.rstrip(b'/.git/').decode(osutils._fs_enc)
 
699
            return ControlDir.open_from_transport(get_transport_from_path(commondir))