/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 empty directories that are not allowed in git.

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