/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/plugins/git/dir.py

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

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.unescape(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 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
                base_url = urlutils.local_path_to_url(self.control_transport.get_bytes('commondir')).rstrip('/.git/')+'/'
 
496
            except bzr_errors.NoSuchFile:
 
497
                base_url = self.user_url.rstrip('/')
 
498
            if not PY3:
 
499
                params = {k: v.encode('utf-8') for (k, v) in viewitems(params)}
 
500
            return urlutils.join_segment_parameters(base_url, params)
 
501
        return None
 
502
 
 
503
    def find_branch_format(self, name=None):
 
504
        from .branch import (
 
505
            LocalGitBranchFormat,
 
506
            )
 
507
        ref = self._get_selected_ref(name)
 
508
        return LocalGitBranchFormat()
 
509
 
 
510
    def get_branch_transport(self, branch_format, name=None):
 
511
        if branch_format is None:
 
512
            return self.transport
 
513
        if isinstance(branch_format, LocalGitControlDirFormat):
 
514
            return self.transport
 
515
        raise bzr_errors.IncompatibleFormat(branch_format, self._format)
 
516
 
 
517
    def get_repository_transport(self, format):
 
518
        if format is None:
 
519
            return self.transport
 
520
        if isinstance(format, LocalGitControlDirFormat):
 
521
            return self.transport
 
522
        raise bzr_errors.IncompatibleFormat(format, self._format)
 
523
 
 
524
    def get_workingtree_transport(self, format):
 
525
        if format is None:
 
526
            return self.transport
 
527
        if isinstance(format, LocalGitControlDirFormat):
 
528
            return self.transport
 
529
        raise bzr_errors.IncompatibleFormat(format, self._format)
 
530
 
 
531
    def open_branch(self, name=None, unsupported=False, ignore_fallbacks=None,
 
532
            ref=None, possible_transports=None, nascent_ok=False):
 
533
        """'create' a branch for this dir."""
 
534
        repo = self.find_repository()
 
535
        from .branch import LocalGitBranch
 
536
        ref = self._get_selected_ref(name, ref)
 
537
        if not nascent_ok and ref not in self._git.refs:
 
538
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
539
                    controldir=self)
 
540
        ref_chain, unused_sha = self._git.refs.follow(ref)
 
541
        if ref_chain[-1] == b'HEAD':
 
542
            controldir = self
 
543
        else:
 
544
            controldir = self._find_commondir()
 
545
        return LocalGitBranch(controldir, repo, ref_chain[-1])
 
546
 
 
547
    def destroy_branch(self, name=None):
 
548
        refname = self._get_selected_ref(name)
 
549
        if refname == b'HEAD':
 
550
            # HEAD can't be removed
 
551
            raise bzr_errors.UnsupportedOperation(
 
552
                self.destroy_branch, self)
 
553
        try:
 
554
            del self._git.refs[refname]
 
555
        except KeyError:
 
556
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
557
                    controldir=self)
 
558
 
 
559
    def destroy_repository(self):
 
560
        raise bzr_errors.UnsupportedOperation(self.destroy_repository, self)
 
561
 
 
562
    def destroy_workingtree(self):
 
563
        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree, self)
 
564
 
 
565
    def destroy_workingtree_metadata(self):
 
566
        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree_metadata, self)
 
567
 
 
568
    def needs_format_conversion(self, format=None):
 
569
        return not isinstance(self._format, format.__class__)
 
570
 
 
571
    def open_repository(self):
 
572
        """'open' a repository for this dir."""
 
573
        if self.control_transport.has('commondir'):
 
574
            raise bzr_errors.NoRepositoryPresent(self)
 
575
        return self._gitrepository_class(self)
 
576
 
 
577
    def has_workingtree(self):
 
578
        return not self._git.bare
 
579
 
 
580
    def open_workingtree(self, recommend_upgrade=True, unsupported=False):
 
581
        if not self._git.bare:
 
582
            from dulwich.errors import NoIndexPresent
 
583
            repo = self.find_repository()
 
584
            from .workingtree import GitWorkingTree
 
585
            branch = self.open_branch(ref=b'HEAD', nascent_ok=True)
 
586
            return GitWorkingTree(self, repo, branch)
 
587
        loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
 
588
        raise bzr_errors.NoWorkingTree(loc)
 
589
 
 
590
    def create_repository(self, shared=False):
 
591
        from .repository import GitRepositoryFormat
 
592
        if shared:
 
593
            raise bzr_errors.IncompatibleFormat(GitRepositoryFormat(), self._format)
 
594
        return self.find_repository()
 
595
 
 
596
    def create_branch(self, name=None, repository=None,
 
597
                      append_revisions_only=None, ref=None):
 
598
        refname = self._get_selected_ref(name, ref)
 
599
        if refname != b'HEAD' and refname in self._git.refs:
 
600
            raise bzr_errors.AlreadyBranchError(self.user_url)
 
601
        repo = self.open_repository()
 
602
        if refname in self._git.refs:
 
603
            ref_chain, unused_sha = self._git.refs.follow(self._get_selected_ref(None))
 
604
            if ref_chain[0] == b'HEAD':
 
605
                refname = ref_chain[1]
 
606
        from .branch import LocalGitBranch
 
607
        branch = LocalGitBranch(self, repo, refname)
 
608
        if append_revisions_only:
 
609
            branch.set_append_revisions_only(append_revisions_only)
 
610
        return branch
 
611
 
 
612
    def backup_bzrdir(self):
 
613
        if not self._git.bare:
 
614
            self.root_transport.copy_tree(".git", ".git.backup")
 
615
            return (self.root_transport.abspath(".git"),
 
616
                    self.root_transport.abspath(".git.backup"))
 
617
        else:
 
618
            basename = urlutils.basename(self.root_transport.base)
 
619
            parent = self.root_transport.clone('..')
 
620
            parent.copy_tree(basename, basename + ".backup")
 
621
 
 
622
    def create_workingtree(self, revision_id=None, from_branch=None,
 
623
        accelerator_tree=None, hardlink=False):
 
624
        if self._git.bare:
 
625
            raise bzr_errors.UnsupportedOperation(self.create_workingtree, self)
 
626
        if from_branch is None:
 
627
            from_branch = self.open_branch(nascent_ok=True)
 
628
        if revision_id is None:
 
629
            revision_id = from_branch.last_revision()
 
630
        repo = self.find_repository()
 
631
        from .workingtree import GitWorkingTree
 
632
        wt = GitWorkingTree(self, repo, from_branch)
 
633
        wt.set_last_revision(revision_id)
 
634
        wt._build_checkout_with_index()
 
635
        return wt
 
636
 
 
637
    def _find_or_create_repository(self, force_new_repo=None):
 
638
        return self.create_repository(shared=False)
 
639
 
 
640
    def _find_creation_modes(self):
 
641
        """Determine the appropriate modes for files and directories.
 
642
 
 
643
        They're always set to be consistent with the base directory,
 
644
        assuming that this transport allows setting modes.
 
645
        """
 
646
        # TODO: Do we need or want an option (maybe a config setting) to turn
 
647
        # this off or override it for particular locations? -- mbp 20080512
 
648
        if self._mode_check_done:
 
649
            return
 
650
        self._mode_check_done = True
 
651
        try:
 
652
            st = self.transport.stat('.')
 
653
        except bzr_errors.TransportNotPossible:
 
654
            self._dir_mode = None
 
655
            self._file_mode = None
 
656
        else:
 
657
            # Check the directory mode, but also make sure the created
 
658
            # directories and files are read-write for this user. This is
 
659
            # mostly a workaround for filesystems which lie about being able to
 
660
            # write to a directory (cygwin & win32)
 
661
            if (st.st_mode & 0o7777 == 0o0000):
 
662
                # FTP allows stat but does not return dir/file modes
 
663
                self._dir_mode = None
 
664
                self._file_mode = None
 
665
            else:
 
666
                self._dir_mode = (st.st_mode & 0o7777) | 0o0700
 
667
                # Remove the sticky and execute bits for files
 
668
                self._file_mode = self._dir_mode & ~0o7111
 
669
 
 
670
    def _get_file_mode(self):
 
671
        """Return Unix mode for newly created files, or None.
 
672
        """
 
673
        if not self._mode_check_done:
 
674
            self._find_creation_modes()
 
675
        return self._file_mode
 
676
 
 
677
    def _get_dir_mode(self):
 
678
        """Return Unix mode for newly created directories, or None.
 
679
        """
 
680
        if not self._mode_check_done:
 
681
            self._find_creation_modes()
 
682
        return self._dir_mode
 
683
 
 
684
    def get_refs_container(self):
 
685
        return self._git.refs
 
686
 
 
687
    def get_peeled(self, ref):
 
688
        return self._git.get_peeled(ref)
 
689
 
 
690
    def _find_commondir(self):
 
691
        try:
 
692
            commondir = self.control_transport.get_bytes('commondir')
 
693
        except bzr_errors.NoSuchFile:
 
694
            return self
 
695
        else:
 
696
            commondir = commondir.rstrip(b'/.git/')
 
697
            return ControlDir.open_from_transport(get_transport_from_path(commondir))