/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: 2020-01-19 15:14:16 UTC
  • mto: This revision was merged to the branch mainline in revision 7455.
  • Revision ID: jelmer@jelmer.uk-20200119151416-f2x9y9rtvwxndr2l
Don't show submodules that are not checked out as deltas.

Show diffs side-by-side

added added

removed removed

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