/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

Cope with submodules in working trees.

Show diffs side-by-side

added added

removed removed

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