/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
# 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
        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):
 
114
    """An adapter to the '.git' dir used by git."""
 
115
 
 
116
    def is_supported(self):
 
117
        return True
 
118
 
 
119
    def can_convert_format(self):
 
120
        return False
 
121
 
 
122
    def break_lock(self):
 
123
        pass
 
124
 
 
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
 
171
        if stacked:
 
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)"
 
306
 
 
307
 
 
308
class LocalGitDir(GitDir):
 
309
    """An adapter to the '.git' dir used by git."""
 
310
 
 
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
 
328
 
 
329
    def __init__(self, transport, lockfiles, gitrepo, format):
 
330
        self._format = format
 
331
        self.root_transport = transport
 
332
        self._mode_check_done = False
 
333
        self._git = gitrepo
 
334
        if gitrepo.bare:
 
335
            self.transport = transport
 
336
        else:
 
337
            self.transport = transport.clone('.git')
 
338
        self._lockfiles = lockfiles
 
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):
 
384
        if branch_format is None:
 
385
            return self.transport
 
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):
 
405
        """'create' a branch for this dir."""
 
406
        repo = self.open_repository()
 
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):
 
441
        """'open' a repository for this dir."""
 
442
        return self._gitrepository_class(self, self._lockfiles)
 
443
 
 
444
    def open_workingtree(self, recommend_upgrade=True):
 
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)
 
462
 
 
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)
 
467
        return self.open_repository()
 
468
 
 
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
 
548