/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: 2019-06-21 11:21:12 UTC
  • mto: This revision was merged to the branch mainline in revision 7352.
  • Revision ID: jelmer@jelmer.uk-20190621112112-v0uorrdgqib5z1ur
For python 2.x, install sphinx 1.8.5. Newer versions don't support python 2.

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