/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

Use dictionary with verifiers rather than requiring testament3-sha1 everywhere.

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
 
18
"""An adapter between a Git control dir and a Bazaar ControlDir."""
 
19
 
22
20
from bzrlib import (
23
 
    bzrdir,
 
21
    errors as bzr_errors,
24
22
    lockable_files,
25
23
    urlutils,
 
24
    version_info as bzrlib_version,
26
25
    )
27
26
 
28
27
LockWarner = getattr(lockable_files, "_LockWarner", None)
29
28
 
30
29
from bzrlib.plugins.git import (
31
 
    LocalGitBzrDirFormat,
32
 
    branch,
33
 
    errors,
34
 
    get_rich_root_format,
35
 
    repository,
36
 
    workingtree,
 
30
    LocalGitControlDirFormat,
37
31
    )
 
32
try:
 
33
    from bzrlib.controldir import (
 
34
        ControlDir,
 
35
        format_registry,
 
36
        )
 
37
except ImportError:
 
38
    # bzr < 2.3
 
39
    from bzrlib.bzrdir import (
 
40
        BzrDir,
 
41
        format_registry,
 
42
        )
 
43
    ControlDir = BzrDir
38
44
 
39
45
 
40
46
class GitLock(object):
55
61
    def validate_token(self, token):
56
62
        pass
57
63
 
 
64
    def break_lock(self):
 
65
        pass
 
66
 
58
67
 
59
68
class GitLockableFiles(lockable_files.LockableFiles):
60
69
    """Git specific lockable files abstraction."""
71
80
            self._lock_warner = LockWarner(repr(self))
72
81
 
73
82
 
74
 
class GitDir(bzrdir.BzrDir):
 
83
class GitDirConfig(object):
 
84
 
 
85
    def get_default_stack_on(self):
 
86
        return None
 
87
 
 
88
    def set_default_stack_on(self, value):
 
89
        raise bzr_errors.BzrError("Cannot set configuration")
 
90
 
 
91
 
 
92
class GitDir(ControlDir):
75
93
    """An adapter to the '.git' dir used by git."""
76
94
 
77
95
    def is_supported(self):
78
96
        return True
79
97
 
 
98
    def can_convert_format(self):
 
99
        return False
 
100
 
 
101
    def break_lock(self):
 
102
        pass
 
103
 
80
104
    def cloning_metadir(self, stacked=False):
81
 
        return get_rich_root_format(stacked)
 
105
        return format_registry.make_bzrdir("default")
 
106
 
 
107
    def _branch_name_to_ref(self, name):
 
108
        raise NotImplementedError(self._branch_name_to_ref)
 
109
 
 
110
    if bzrlib_version >= (2, 2):
 
111
        def open_branch(self, name=None, unsupported=False, 
 
112
            ignore_fallbacks=None):
 
113
            return self._open_branch(name=name,
 
114
                ignore_fallbacks=ignore_fallbacks, unsupported=unsupported)
 
115
    else:
 
116
        def open_branch(self, ignore_fallbacks=None, unsupported=False):
 
117
            return self._open_branch(name=None,
 
118
                ignore_fallbacks=ignore_fallbacks, unsupported=unsupported)
 
119
 
 
120
    def get_config(self):
 
121
        return GitDirConfig()
82
122
 
83
123
 
84
124
class LocalGitDir(GitDir):
85
125
    """An adapter to the '.git' dir used by git."""
86
126
 
87
 
    _gitrepository_class = repository.LocalGitRepository
 
127
    def _get_gitrepository_class(self):
 
128
        from bzrlib.plugins.git.repository import LocalGitRepository
 
129
        return LocalGitRepository
 
130
 
 
131
    _gitrepository_class = property(_get_gitrepository_class)
 
132
 
 
133
    @property
 
134
    def user_transport(self):
 
135
        return self.root_transport
 
136
 
 
137
    @property
 
138
    def control_transport(self):
 
139
        return self.transport
88
140
 
89
141
    def __init__(self, transport, lockfiles, gitrepo, format):
90
142
        self._format = format
91
143
        self.root_transport = transport
 
144
        self._mode_check_done = False
92
145
        self._git = gitrepo
93
146
        if gitrepo.bare:
94
147
            self.transport = transport
97
150
        self._lockfiles = lockfiles
98
151
        self._mode_check_done = None
99
152
 
 
153
    def _branch_name_to_ref(self, name):
 
154
        from bzrlib.plugins.git.refs import branch_name_to_ref
 
155
        ref = branch_name_to_ref(name, None)
 
156
        if ref == "HEAD":
 
157
            from dulwich.repo import SYMREF
 
158
            refcontents = self._git.refs.read_ref(ref)
 
159
            if refcontents.startswith(SYMREF):
 
160
                ref = refcontents[len(SYMREF):]
 
161
        return ref
 
162
 
100
163
    def is_control_filename(self, filename):
101
164
        return filename == '.git' or filename.startswith('.git/')
102
165
 
103
 
    def get_branch_transport(self, branch_format):
 
166
    def get_branch_transport(self, branch_format, name=None):
104
167
        if branch_format is None:
105
168
            return self.transport
106
 
        if isinstance(branch_format, LocalGitBzrDirFormat):
107
 
            return self.transport
108
 
        raise errors.bzr_errors.IncompatibleFormat(branch_format, self._format)
109
 
 
110
 
    get_repository_transport = get_branch_transport
111
 
    get_workingtree_transport = get_branch_transport
112
 
 
113
 
    def open_branch(self, ignore_fallbacks=None):
 
169
        if isinstance(branch_format, LocalGitControlDirFormat):
 
170
            return self.transport
 
171
        raise bzr_errors.IncompatibleFormat(branch_format, self._format)
 
172
 
 
173
    def get_repository_transport(self, format):
 
174
        if format is None:
 
175
            return self.transport
 
176
        if isinstance(format, LocalGitControlDirFormat):
 
177
            return self.transport
 
178
        raise bzr_errors.IncompatibleFormat(format, self._format)
 
179
 
 
180
    def get_workingtree_transport(self, format):
 
181
        if format is None:
 
182
            return self.transport
 
183
        if isinstance(format, LocalGitControlDirFormat):
 
184
            return self.transport
 
185
        raise bzr_errors.IncompatibleFormat(format, self._format)
 
186
 
 
187
    def _open_branch(self, name=None, ignore_fallbacks=None, unsupported=False):
114
188
        """'create' a branch for this dir."""
115
189
        repo = self.open_repository()
116
 
        return branch.LocalGitBranch(self, repo, "HEAD", self._lockfiles)
 
190
        from bzrlib.plugins.git.branch import LocalGitBranch
 
191
        return LocalGitBranch(self, repo, self._branch_name_to_ref(name),
 
192
            self._lockfiles)
 
193
 
 
194
    def destroy_branch(self, name=None):
 
195
        refname = self._branch_name_to_ref(name)
 
196
        if not refname in self._git.refs:
 
197
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
198
                    bzrdir=self)
 
199
        del self._git.refs[refname]
 
200
 
 
201
    def destroy_repository(self):
 
202
        raise bzr_errors.UnsupportedOperation(self.destroy_repository, self)
 
203
 
 
204
    def destroy_workingtree(self):
 
205
        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree, self)
 
206
 
 
207
    def needs_format_conversion(self, format=None):
 
208
        return not isinstance(self._format, format.__class__)
 
209
 
 
210
    def list_branches(self):
 
211
        ret = []
 
212
        for name in self._git.get_refs():
 
213
            if name.startswith("refs/heads/"):
 
214
                ret.append(self.open_branch(name=name))
 
215
        return ret
117
216
 
118
217
    def open_repository(self, shared=False):
119
218
        """'open' a repository for this dir."""
120
219
        return self._gitrepository_class(self, self._lockfiles)
121
220
 
122
221
    def open_workingtree(self, recommend_upgrade=True):
123
 
        if not self._git.bare and self._git.has_index():
124
 
            return workingtree.GitWorkingTree(self, self.open_repository(), 
125
 
                                                  self.open_branch())
 
222
        if not self._git.bare:
 
223
            from dulwich.errors import NoIndexPresent
 
224
            repo = self.open_repository()
 
225
            try:
 
226
                index = repo._git.open_index()
 
227
            except NoIndexPresent:
 
228
                pass
 
229
            else:
 
230
                from bzrlib.plugins.git.workingtree import GitWorkingTree
 
231
                try:
 
232
                    branch = self.open_branch()
 
233
                except bzr_errors.NotBranchError:
 
234
                    pass
 
235
                else:
 
236
                    return GitWorkingTree(self, repo, branch, index)
126
237
        loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
127
 
        raise errors.bzr_errors.NoWorkingTree(loc)
 
238
        raise bzr_errors.NoWorkingTree(loc)
128
239
 
129
240
    def create_repository(self, shared=False):
130
241
        return self.open_repository()
131
242
 
132
 
    def create_branch(self):
133
 
        return self.open_branch()
 
243
    def create_branch(self, name=None):
 
244
        refname = self._branch_name_to_ref(name)
 
245
        from dulwich.protocol import ZERO_SHA
 
246
        self._git.refs[refname or "HEAD"] = ZERO_SHA
 
247
        return self.open_branch(name)
134
248
 
135
249
    def backup_bzrdir(self):
136
250
        if self._git.bare:
138
252
            return (self.root_transport.abspath(".git"),
139
253
                    self.root_transport.abspath(".git.backup"))
140
254
        else:
141
 
            raise errors.bzr_errors.BzrError("Unable to backup bare repositories")
 
255
            raise bzr_errors.BzrError("Unable to backup bare repositories")
142
256
 
143
257
    def create_workingtree(self, revision_id=None, from_branch=None,
144
258
        accelerator_tree=None, hardlink=False):
145
259
        if self._git.bare:
146
 
            raise errors.bzr_errors.BzrError("Can't create working tree in a bare repo")
 
260
            raise bzr_errors.BzrError("Can't create working tree in a bare repo")
147
261
        from dulwich.index import write_index
148
 
        write_index(self.root_transport.abspath(".git/index"), [])
 
262
        from dulwich.pack import SHA1Writer
 
263
        f = open(self.transport.local_abspath("index"), 'w+')
 
264
        try:
 
265
            f = SHA1Writer(f)
 
266
            write_index(f, [])
 
267
        finally:
 
268
            f.close()
149
269
        return self.open_workingtree()
 
270
 
 
271
    def find_repository(self):
 
272
        """Find the repository that should be used.
 
273
 
 
274
        This does not require a branch as we use it to find the repo for
 
275
        new branches as well as to hook existing branches up to their
 
276
        repository.
 
277
        """
 
278
        return self.open_repository()
 
279
 
 
280
    def _find_creation_modes(self):
 
281
        """Determine the appropriate modes for files and directories.
 
282
 
 
283
        They're always set to be consistent with the base directory,
 
284
        assuming that this transport allows setting modes.
 
285
        """
 
286
        # TODO: Do we need or want an option (maybe a config setting) to turn
 
287
        # this off or override it for particular locations? -- mbp 20080512
 
288
        if self._mode_check_done:
 
289
            return
 
290
        self._mode_check_done = True
 
291
        try:
 
292
            st = self.transport.stat('.')
 
293
        except TransportNotPossible:
 
294
            self._dir_mode = None
 
295
            self._file_mode = None
 
296
        else:
 
297
            # Check the directory mode, but also make sure the created
 
298
            # directories and files are read-write for this user. This is
 
299
            # mostly a workaround for filesystems which lie about being able to
 
300
            # write to a directory (cygwin & win32)
 
301
            if (st.st_mode & 07777 == 00000):
 
302
                # FTP allows stat but does not return dir/file modes
 
303
                self._dir_mode = None
 
304
                self._file_mode = None
 
305
            else:
 
306
                self._dir_mode = (st.st_mode & 07777) | 00700
 
307
                # Remove the sticky and execute bits for files
 
308
                self._file_mode = self._dir_mode & ~07111
 
309
 
 
310
    def _get_file_mode(self):
 
311
        """Return Unix mode for newly created files, or None.
 
312
        """
 
313
        if not self._mode_check_done:
 
314
            self._find_creation_modes()
 
315
        return self._file_mode
 
316
 
 
317
    def _get_dir_mode(self):
 
318
        """Return Unix mode for newly created directories, or None.
 
319
        """
 
320
        if not self._mode_check_done:
 
321
            self._find_creation_modes()
 
322
        return self._dir_mode
 
323
 
 
324