/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-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

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