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

Fix more tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
dir.py
1
1
# Copyright (C) 2007 Canonical Ltd
 
2
# Copyright (C) 2010 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
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
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
 
18
"""An adapter between a Git control dir and a Bazaar ControlDir."""
 
19
 
 
20
import urllib
 
21
 
23
22
from bzrlib import (
24
 
    bzrdir,
 
23
    errors as bzr_errors,
25
24
    lockable_files,
 
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,
 
29
from bzrlib.bzrdir import CreateRepository
 
30
from bzrlib.transport import do_catching_redirections
 
31
 
 
32
LockWarner = getattr(lockable_files, "_LockWarner", None)
 
33
 
 
34
from bzrlib.controldir import (
 
35
    ControlDir,
 
36
    ControlDirFormat,
 
37
    format_registry,
36
38
    )
37
 
""")
38
 
 
39
39
 
40
40
 
41
41
class GitLock(object):
42
42
    """A lock that thunks through to Git."""
43
43
 
 
44
    def __init__(self):
 
45
        self.lock_name = "git lock"
 
46
 
44
47
    def lock_write(self, token=None):
45
48
        pass
46
49
 
56
59
    def validate_token(self, token):
57
60
        pass
58
61
 
 
62
    def break_lock(self):
 
63
        raise NotImplementedError(self.break_lock)
 
64
 
 
65
    def dont_leave_in_place(self):
 
66
        raise NotImplementedError(self.dont_leave_in_place)
 
67
 
 
68
    def leave_in_place(self):
 
69
        raise NotImplementedError(self.leave_in_place)
 
70
 
59
71
 
60
72
class GitLockableFiles(lockable_files.LockableFiles):
61
73
    """Git specific lockable files abstraction."""
64
76
        self._lock = lock
65
77
        self._transaction = None
66
78
        self._lock_mode = None
67
 
        self._lock_count = 0
68
79
        self._transport = transport
69
 
 
70
 
 
71
 
class GitDir(bzrdir.BzrDir):
 
80
        if LockWarner is None:
 
81
            # Bzr 1.13
 
82
            self._lock_count = 0
 
83
        else:
 
84
            self._lock_warner = LockWarner(repr(self))
 
85
 
 
86
 
 
87
class GitDirConfig(object):
 
88
 
 
89
    def get_default_stack_on(self):
 
90
        return None
 
91
 
 
92
    def set_default_stack_on(self, value):
 
93
        raise bzr_errors.BzrError("Cannot set configuration")
 
94
 
 
95
 
 
96
class GitControlDirFormat(ControlDirFormat):
 
97
 
 
98
    _lock_class = lockable_files.TransportLock
 
99
 
 
100
    colocated_branches = True
 
101
    fixed_components = True
 
102
 
 
103
    def __eq__(self, other):
 
104
        return type(self) == type(other)
 
105
 
 
106
    def is_supported(self):
 
107
        return True
 
108
 
 
109
    def network_name(self):
 
110
        return "git"
 
111
 
 
112
 
 
113
class GitDir(ControlDir):
72
114
    """An adapter to the '.git' dir used by git."""
73
115
 
74
116
    def is_supported(self):
75
117
        return True
76
118
 
 
119
    def can_convert_format(self):
 
120
        return False
 
121
 
 
122
    def break_lock(self):
 
123
        pass
 
124
 
77
125
    def cloning_metadir(self, stacked=False):
 
126
        return format_registry.make_bzrdir("default")
 
127
 
 
128
    def checkout_metadir(self, stacked=False):
 
129
        return format_registry.make_bzrdir("default")
 
130
 
 
131
    def _get_selected_ref(self, branch):
 
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 bzrlib.plugins.git.refs import branch_name_to_ref
 
136
            return branch_name_to_ref(branch, None)
 
137
        segment_parameters = getattr(
 
138
            self.user_transport, "get_segment_parameters", lambda: {})()
 
139
        ref = segment_parameters.get("ref")
 
140
        if ref is not None:
 
141
            ref = urlutils.unescape(ref)
 
142
        return ref
 
143
 
 
144
    def get_config(self):
 
145
        return GitDirConfig()
 
146
 
 
147
    def _available_backup_name(self, base):
 
148
        return osutils.available_backup_name(base, self.root_transport.has)
 
149
 
 
150
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
151
               recurse='down', possible_transports=None,
 
152
               accelerator_tree=None, hardlink=False, stacked=False,
 
153
               source_branch=None, create_tree_if_local=True):
 
154
        from bzrlib.repository import InterRepository
 
155
        from bzrlib.transport.local import LocalTransport
 
156
        from bzrlib.transport import get_transport
 
157
        target_transport = get_transport(url, possible_transports)
 
158
        target_transport.ensure_base()
 
159
        cloning_format = self.cloning_metadir()
 
160
        # Create/update the result branch
 
161
        result = cloning_format.initialize_on_transport(target_transport)
 
162
        source_branch = self.open_branch()
 
163
        source_repository = self.find_repository()
 
164
        try:
 
165
            result_repo = result.find_repository()
 
166
        except bzr_errors.NoRepositoryPresent:
 
167
            result_repo = result.create_repository()
 
168
            target_is_empty = True
 
169
        else:
 
170
            target_is_empty = None # Unknown
78
171
        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")
 
172
            raise bzr_errors.IncompatibleRepositories(source_repository, result_repo)
 
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(result,
 
183
            revision_id=revision_id, repository=result_repo)
 
184
        if (create_tree_if_local and isinstance(target_transport, LocalTransport)
 
185
            and (result_repo is None or result_repo.make_working_trees())):
 
186
            wt = result.create_workingtree(accelerator_tree=accelerator_tree,
 
187
                hardlink=hardlink, from_branch=result_branch)
 
188
            wt.lock_write()
 
189
            try:
 
190
                if wt.path2id('') is None:
 
191
                    try:
 
192
                        wt.set_root_id(self.open_workingtree.get_root_id())
 
193
                    except bzr_errors.NoWorkingTree:
 
194
                        pass
 
195
            finally:
 
196
                wt.unlock()
 
197
        return result
 
198
 
 
199
    def clone_on_transport(self, transport, revision_id=None,
 
200
        force_new_repo=False, preserve_stacking=False, stacked_on=None,
 
201
        create_prefix=False, use_existing_dir=True, no_tree=False):
 
202
        """See ControlDir.clone_on_transport."""
 
203
        from bzrlib.repository import InterRepository
 
204
        from bzrlib.plugins.git.mapping import default_mapping
 
205
        if no_tree:
 
206
            format = BareLocalGitControlDirFormat()
 
207
        else:
 
208
            format = LocalGitControlDirFormat()
 
209
        (target_repo, target_controldir, stacking, repo_policy) = format.initialize_on_transport_ex(transport, use_existing_dir=use_existing_dir, create_prefix=create_prefix, force_new_repo=force_new_repo)
 
210
        target_git_repo = target_repo._git
 
211
        source_repo = self.open_repository()
 
212
        source_git_repo = source_repo._git
 
213
        interrepo = InterRepository.get(source_repo, target_repo)
 
214
        if revision_id is not None:
 
215
            determine_wants = interrepo.get_determine_wants_revids([revision_id], include_tags=True)
 
216
        else:
 
217
            determine_wants = interrepo.determine_wants_all
 
218
        (pack_hint, _, refs) = interrepo.fetch_objects(determine_wants,
 
219
            mapping=default_mapping)
 
220
        for name, val in refs.iteritems():
 
221
            target_git_repo.refs[name] = val
 
222
        lockfiles = GitLockableFiles(transport, GitLock())
 
223
        return self.__class__(transport, lockfiles, target_git_repo, format)
 
224
 
 
225
    def find_repository(self):
 
226
        """Find the repository that should be used.
 
227
 
 
228
        This does not require a branch as we use it to find the repo for
 
229
        new branches as well as to hook existing branches up to their
 
230
        repository.
 
231
        """
 
232
        return self.open_repository()
 
233
 
 
234
 
 
235
class LocalGitControlDirFormat(GitControlDirFormat):
 
236
    """The .git directory control format."""
 
237
 
 
238
    bare = False
 
239
 
 
240
    @classmethod
 
241
    def _known_formats(self):
 
242
        return set([LocalGitControlDirFormat()])
 
243
 
 
244
    @property
 
245
    def repository_format(self):
 
246
        from bzrlib.plugins.git.repository import GitRepositoryFormat
 
247
        return GitRepositoryFormat()
 
248
 
 
249
    def get_branch_format(self):
 
250
        from bzrlib.plugins.git.branch import GitBranchFormat
 
251
        return GitBranchFormat()
 
252
 
 
253
    def open(self, transport, _found=None):
 
254
        """Open this directory.
 
255
 
 
256
        """
 
257
        from bzrlib.plugins.git.transportgit import TransportRepo
 
258
        gitrepo = TransportRepo(transport)
 
259
        lockfiles = GitLockableFiles(transport, GitLock())
 
260
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
261
 
 
262
    def get_format_description(self):
 
263
        return "Local Git Repository"
 
264
 
 
265
    def initialize_on_transport(self, transport):
 
266
        from bzrlib.plugins.git.transportgit import TransportRepo
 
267
        TransportRepo.init(transport, bare=self.bare)
 
268
        return self.open(transport)
 
269
 
 
270
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
271
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
272
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
273
        shared_repo=False, vfs_only=False):
 
274
        def make_directory(transport):
 
275
            transport.mkdir('.')
 
276
            return transport
 
277
        def redirected(transport, e, redirection_notice):
 
278
            trace.note(redirection_notice)
 
279
            return transport._redirected_to(e.source, e.target)
 
280
        try:
 
281
            transport = do_catching_redirections(make_directory, transport,
 
282
                redirected)
 
283
        except bzr_errors.FileExists:
 
284
            if not use_existing_dir:
 
285
                raise
 
286
        except bzr_errors.NoSuchFile:
 
287
            if not create_prefix:
 
288
                raise
 
289
            transport.create_prefix()
 
290
        controldir = self.initialize_on_transport(transport)
 
291
        repository = controldir.open_repository()
 
292
        repository.lock_write()
 
293
        return (repository, controldir, False, CreateRepository(controldir))
 
294
 
 
295
    def is_supported(self):
 
296
        return True
 
297
 
 
298
 
 
299
class BareLocalGitControlDirFormat(LocalGitControlDirFormat):
 
300
 
 
301
    bare = True
 
302
    supports_workingtrees = False
 
303
 
 
304
    def get_format_description(self):
 
305
        return "Local Git Repository (bare)"
82
306
 
83
307
 
84
308
class LocalGitDir(GitDir):
85
309
    """An adapter to the '.git' dir used by git."""
86
310
 
87
 
    _gitrepository_class = repository.LocalGitRepository
 
311
    def _get_gitrepository_class(self):
 
312
        from bzrlib.plugins.git.repository import LocalGitRepository
 
313
        return LocalGitRepository
 
314
 
 
315
    def __repr__(self):
 
316
        return "<%s at %r>" % (
 
317
            self.__class__.__name__, self.root_transport.base)
 
318
 
 
319
    _gitrepository_class = property(_get_gitrepository_class)
 
320
 
 
321
    @property
 
322
    def user_transport(self):
 
323
        return self.root_transport
 
324
 
 
325
    @property
 
326
    def control_transport(self):
 
327
        return self.transport
88
328
 
89
329
    def __init__(self, transport, lockfiles, gitrepo, format):
90
330
        self._format = format
91
331
        self.root_transport = transport
 
332
        self._mode_check_done = False
92
333
        self._git = gitrepo
93
334
        if gitrepo.bare:
94
335
            self.transport = transport
95
336
        else:
96
337
            self.transport = transport.clone('.git')
97
338
        self._lockfiles = lockfiles
98
 
 
99
 
    def get_branch_transport(self, branch_format):
 
339
        self._mode_check_done = None
 
340
 
 
341
    def is_control_filename(self, filename):
 
342
        return (filename == '.git' or filename.startswith('.git/'))
 
343
 
 
344
    def _get_symref(self, ref):
 
345
        from dulwich.repo import SYMREF
 
346
        refcontents = self._git.refs.read_ref(ref)
 
347
        if refcontents is None: # no such ref
 
348
            return None
 
349
        if refcontents.startswith(SYMREF):
 
350
            return refcontents[len(SYMREF):].rstrip("\n")
 
351
        return None
 
352
 
 
353
    def set_branch_reference(self, name, target):
 
354
        ref = self._get_selected_ref(name)
 
355
        if ref is None:
 
356
            ref = "HEAD"
 
357
        if not getattr(target, "ref", None):
 
358
            raise bzr_errors.BzrError("Can only set symrefs to Git refs")
 
359
        self._git.refs.set_symbolic_ref(ref, target.ref)
 
360
 
 
361
    def get_branch_reference(self, name=None):
 
362
        ref = self._get_selected_ref(name)
 
363
        if ref is None:
 
364
            ref = "HEAD"
 
365
        target_ref = self._get_symref(ref)
 
366
        if target_ref is not None:
 
367
            return ",ref=%s" % urllib.quote(target_ref)
 
368
        return None
 
369
 
 
370
    def find_branch_format(self, name=None):
 
371
        from bzrlib.plugins.git.branch import (
 
372
            GitBranchFormat,
 
373
            GitSymrefBranchFormat,
 
374
            )
 
375
        ref = self._get_selected_ref(name)
 
376
        if ref is None:
 
377
            ref = "HEAD"
 
378
        if self._get_symref(ref) is not None:
 
379
            return GitSymrefBranchFormat()
 
380
        else:
 
381
            return GitBranchFormat()
 
382
 
 
383
    def get_branch_transport(self, branch_format, name=None):
100
384
        if branch_format is None:
101
385
            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):
 
386
        if isinstance(branch_format, LocalGitControlDirFormat):
 
387
            return self.transport
 
388
        raise bzr_errors.IncompatibleFormat(branch_format, self._format)
 
389
 
 
390
    def get_repository_transport(self, format):
 
391
        if format is None:
 
392
            return self.transport
 
393
        if isinstance(format, LocalGitControlDirFormat):
 
394
            return self.transport
 
395
        raise bzr_errors.IncompatibleFormat(format, self._format)
 
396
 
 
397
    def get_workingtree_transport(self, format):
 
398
        if format is None:
 
399
            return self.transport
 
400
        if isinstance(format, LocalGitControlDirFormat):
 
401
            return self.transport
 
402
        raise bzr_errors.IncompatibleFormat(format, self._format)
 
403
 
 
404
    def open_branch(self, name=None, unsupported=False, ignore_fallbacks=None):
110
405
        """'create' a branch for this dir."""
111
406
        repo = self.open_repository()
112
 
        return branch.LocalGitBranch(self, repo, "HEAD", repo._git.head(), self._lockfiles)
113
 
 
114
 
    def open_repository(self, shared=False):
 
407
        from bzrlib.plugins.git.branch import LocalGitBranch
 
408
        ref = self._get_selected_ref(name)
 
409
        if ref is None:
 
410
            ref = "HEAD"
 
411
        ref, sha = self._git.refs._follow(ref)
 
412
        if not ref in self._git.refs:
 
413
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
414
                    bzrdir=self)
 
415
        return LocalGitBranch(self, repo, ref, self._lockfiles)
 
416
 
 
417
    def destroy_branch(self, name=None):
 
418
        refname = self._get_selected_ref(name)
 
419
        if not refname in self._git.refs:
 
420
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
421
                    bzrdir=self)
 
422
        del self._git.refs[refname]
 
423
 
 
424
    def destroy_repository(self):
 
425
        raise bzr_errors.UnsupportedOperation(self.destroy_repository, self)
 
426
 
 
427
    def destroy_workingtree(self):
 
428
        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree, self)
 
429
 
 
430
    def needs_format_conversion(self, format=None):
 
431
        return not isinstance(self._format, format.__class__)
 
432
 
 
433
    def list_branches(self):
 
434
        ret = []
 
435
        for name in self._git.refs.keys():
 
436
            if name.startswith("refs/heads/"):
 
437
                ret.append(self.open_branch(name=name))
 
438
        return ret
 
439
 
 
440
    def open_repository(self):
115
441
        """'open' a repository for this dir."""
116
442
        return self._gitrepository_class(self, self._lockfiles)
117
443
 
118
444
    def open_workingtree(self, recommend_upgrade=True):
119
 
        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())
 
445
        if not self._git.bare:
 
446
            from dulwich.errors import NoIndexPresent
 
447
            repo = self.open_repository()
 
448
            try:
 
449
                index = repo._git.open_index()
 
450
            except NoIndexPresent:
 
451
                pass
 
452
            else:
 
453
                from bzrlib.plugins.git.workingtree import GitWorkingTree
 
454
                try:
 
455
                    branch = self.open_branch()
 
456
                except bzr_errors.NotBranchError:
 
457
                    pass
 
458
                else:
 
459
                    return GitWorkingTree(self, repo, branch, index)
 
460
        loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
 
461
        raise bzr_errors.NoWorkingTree(loc)
125
462
 
126
463
    def create_repository(self, shared=False):
 
464
        from bzrlib.plugins.git.repository import GitRepositoryFormat
 
465
        if shared:
 
466
            raise bzr_errors.IncompatibleFormat(GitRepositoryFormat(), self._format)
127
467
        return self.open_repository()
128
468
 
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)
 
469
    def create_branch(self, name=None, repository=None):
 
470
        refname = self._get_selected_ref(name)
 
471
        from dulwich.protocol import ZERO_SHA
 
472
        # FIXME: This is a bit awkward. Perhaps we should have a
 
473
        # a separate method for changing the default branch?
 
474
        if refname is None:
 
475
            refname = "refs/heads/master"
 
476
            self._git.refs.set_symbolic_ref("HEAD", refname)
 
477
        self._git.refs[refname] = ZERO_SHA
 
478
        return self.open_branch(name)
 
479
 
 
480
    def backup_bzrdir(self):
 
481
        if self._git.bare:
 
482
            self.root_transport.copy_tree(".git", ".git.backup")
 
483
            return (self.root_transport.abspath(".git"),
 
484
                    self.root_transport.abspath(".git.backup"))
 
485
        else:
 
486
            raise bzr_errors.BzrError("Unable to backup bare repositories")
 
487
 
 
488
    def create_workingtree(self, revision_id=None, from_branch=None,
 
489
        accelerator_tree=None, hardlink=False):
 
490
        if self._git.bare:
 
491
            raise bzr_errors.UnsupportedOperation(self.create_workingtree, self)
 
492
        from dulwich.index import write_index
 
493
        from dulwich.pack import SHA1Writer
 
494
        f = open(self.transport.local_abspath("index"), 'w+')
 
495
        try:
 
496
            f = SHA1Writer(f)
 
497
            write_index(f, [])
 
498
        finally:
 
499
            f.close()
 
500
        return self.open_workingtree()
 
501
 
 
502
    def _find_or_create_repository(self, force_new_repo=None):
 
503
        return self.create_repository(shared=False)
 
504
 
 
505
    def _find_creation_modes(self):
 
506
        """Determine the appropriate modes for files and directories.
 
507
 
 
508
        They're always set to be consistent with the base directory,
 
509
        assuming that this transport allows setting modes.
 
510
        """
 
511
        # TODO: Do we need or want an option (maybe a config setting) to turn
 
512
        # this off or override it for particular locations? -- mbp 20080512
 
513
        if self._mode_check_done:
 
514
            return
 
515
        self._mode_check_done = True
 
516
        try:
 
517
            st = self.transport.stat('.')
 
518
        except bzr_errors.TransportNotPossible:
 
519
            self._dir_mode = None
 
520
            self._file_mode = None
 
521
        else:
 
522
            # Check the directory mode, but also make sure the created
 
523
            # directories and files are read-write for this user. This is
 
524
            # mostly a workaround for filesystems which lie about being able to
 
525
            # write to a directory (cygwin & win32)
 
526
            if (st.st_mode & 07777 == 00000):
 
527
                # FTP allows stat but does not return dir/file modes
 
528
                self._dir_mode = None
 
529
                self._file_mode = None
 
530
            else:
 
531
                self._dir_mode = (st.st_mode & 07777) | 00700
 
532
                # Remove the sticky and execute bits for files
 
533
                self._file_mode = self._dir_mode & ~07111
 
534
 
 
535
    def _get_file_mode(self):
 
536
        """Return Unix mode for newly created files, or None.
 
537
        """
 
538
        if not self._mode_check_done:
 
539
            self._find_creation_modes()
 
540
        return self._file_mode
 
541
 
 
542
    def _get_dir_mode(self):
 
543
        """Return Unix mode for newly created directories, or None.
 
544
        """
 
545
        if not self._mode_check_done:
 
546
            self._find_creation_modes()
 
547
        return self._dir_mode
251
548