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
- browse files at revision 0.200.114
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.114
- Committer: Jelmer Vernooij
- Date: 2008-11-25 03:35:52 UTC
- mfrom: (0.208.8 trunk)
- mto: (0.312.1 master) (6883.23.1 bundle-git)
- mto: This revision was merged to the branch mainline in revision 6960.
- Revision ID: jelmer@samba.org-20081125033552-pcdinr6qqxcuhd1c
Fix reporting of git commits in 'bzr log'.
- files added:
- foreign
- files removed:
- HACKING
- notes
- files renamed:
- tests/test_mapping.py => tests/test_ids.py
- files modified:
- .bzrignore
added
removed
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."""
19
17
"""An adapter between a Git control dir and a Bazaar BzrDir"""
18
19
import git, os
20
21
import bzrlib
22
from bzrlib.lazy_import import lazy_import
20
23
from bzrlib import (
21
errors as bzr_errors,
24
bzrdir,
22
25
lockable_files,
23
26
urlutils,
24
version_info as bzrlib_version,
25
27
)
26
28
27
LockWarner = getattr(lockable_files, "_LockWarner", None)
28
29
lazy_import(globals(), """
30
from bzrlib.lockable_files import TransportLock
29
31
from bzrlib.plugins.git import (
30
BareLocalGitControlDirFormat,
31
LocalGitControlDirFormat,
32
errors,
33
branch,
34
repository,
35
workingtree,
32
36
)
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
37
""")
45
38
46
39
47
40
class GitLock(object):
59
52
def peek(self):
60
53
pass
61
54
62
def validate_token(self, token):
63
pass
64
65
def break_lock(self):
66
pass
67
68
55
69
56
class GitLockableFiles(lockable_files.LockableFiles):
70
57
"""Git specific lockable files abstraction."""
71
58
72
def __init__(self, transport, lock):
59
def __init__(self, lock):
73
60
self._lock = lock
74
61
self._transaction = None
75
62
self._lock_mode = None
76
self._transport = transport
77
if LockWarner is None:
78
# Bzr 1.13
79
self._lock_count = 0
80
else:
81
self._lock_warner = LockWarner(repr(self))
82
83
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):
94
"""An adapter to the '.git' dir used by git."""
95
96
def is_supported(self):
97
return True
98
99
def can_convert_format(self):
100
return False
101
102
def break_lock(self):
103
pass
104
105
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()
123
124
125
class LocalGitDir(GitDir):
126
"""An adapter to the '.git' dir used by git."""
127
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
63
self._lock_count = 0
64
65
66
class GitDir(bzrdir.BzrDir):
67
"""An adapter to the '.git' dir used by git."""
68
69
_gitrepository_class = repository.GitRepository
141
70
142
71
def __init__(self, transport, lockfiles, gitrepo, format):
143
72
self._format = format
144
73
self.root_transport = transport
145
self._mode_check_done = False
146
74
self._git = gitrepo
147
75
if gitrepo.bare:
148
76
self.transport = transport
149
77
else:
150
78
self.transport = transport.clone('.git')
151
79
self._lockfiles = lockfiles
152
self._mode_check_done = None
153
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
def is_control_filename(self, filename):
165
return filename == '.git' or filename.startswith('.git/')
166
167
def get_branch_transport(self, branch_format, name=None):
80
81
def get_branch_transport(self, branch_format):
168
82
if branch_format is None:
169
83
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):
84
if isinstance(branch_format, GitBzrDirFormat):
85
return self.transport
86
raise errors.bzr_errors.IncompatibleFormat(branch_format, self._format)
87
88
get_repository_transport = get_branch_transport
89
get_workingtree_transport = get_branch_transport
90
91
def is_supported(self):
92
return True
93
94
def open_branch(self, ignored=None):
189
95
"""'create' a branch for this dir."""
190
96
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
97
if repo._git.heads == []:
98
head = None
99
else:
100
head = repo._git.heads[0].commit.id
101
return branch.GitBranch(self, repo, head,
102
self.root_transport.base, self._lockfiles)
217
103
218
104
def open_repository(self, shared=False):
219
105
"""'open' a repository for this dir."""
220
106
return self._gitrepository_class(self, self._lockfiles)
221
107
222
108
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)
238
loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
239
raise bzr_errors.NoWorkingTree(loc)
109
if self._git.bare:
110
loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
111
raise errors.bzr_errors.NoWorkingTree(loc)
112
else:
113
return workingtree.GitWorkingTree(self, self.open_repository(),
114
self.open_branch())
115
116
def cloning_metadir(self, stacked=False):
117
if stacked:
118
return bzrlib.bzrdir.format_registry.make_bzrdir("pack-0.92")
119
else:
120
return bzrlib.bzrdir.format_registry.make_bzrdir("1.6")
240
121
241
122
def create_repository(self, shared=False):
242
123
return self.open_repository()
243
124
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)
249
250
def backup_bzrdir(self):
251
if self._git.bare:
252
self.root_transport.copy_tree(".git", ".git.backup")
253
return (self.root_transport.abspath(".git"),
254
self.root_transport.abspath(".git.backup"))
255
else:
256
raise bzr_errors.BzrError("Unable to backup bare repositories")
257
258
def create_workingtree(self, revision_id=None, from_branch=None,
259
accelerator_tree=None, hardlink=False):
260
if self._git.bare:
261
raise bzr_errors.BzrError("Can't create working tree in a bare repo")
262
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()
270
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
125
126
class GitBzrDirFormat(bzrdir.BzrDirFormat):
127
"""The .git directory control format."""
128
129
_gitdir_class = GitDir
130
_lock_class = TransportLock
131
132
@classmethod
133
def _known_formats(self):
134
return set([GitBzrDirFormat()])
135
136
def open(self, transport, _found=None):
137
"""Open this directory.
138
139
"""
140
# we dont grok readonly - git isn't integrated with transport.
141
url = transport.base
142
if url.startswith('readonly+'):
143
url = url[len('readonly+'):]
144
145
try:
146
gitrepo = git.repo.Repo(transport.local_abspath("."))
147
except errors.bzr_errors.NotLocalUrl:
148
raise errors.bzr_errors.NotBranchError(path=transport.base)
149
lockfiles = GitLockableFiles(GitLock())
150
return self._gitdir_class(transport, lockfiles, gitrepo, self)
151
152
@classmethod
153
def probe_transport(klass, transport):
154
"""Our format is present if the transport ends in '.not/'."""
155
# little ugly, but works
156
format = klass()
157
# delegate to the main opening code. This pays a double rtt cost at the
158
# moment, so perhaps we want probe_transport to return the opened thing
159
# rather than an openener ? or we could return a curried thing with the
160
# dir to open already instantiated ? Needs more thought.
161
try:
162
format.open(transport)
163
return format
164
except Exception, e:
165
raise errors.bzr_errors.NotBranchError(path=transport.base)
166
raise errors.bzr_errors.NotBranchError(path=transport.base)
167
168
def get_format_description(self):
169
return "Local Git Repository"
170
171
def get_format_string(self):
172
return "Local Git Repository"
173
174
def initialize_on_transport(self, transport):
175
from bzrlib.transport.local import LocalTransport
176
177
if not isinstance(transport, LocalTransport):
178
raise NotImplementedError(self.initialize,
179
"Can't create Git Repositories/branches on "
180
"non-local transports")
181
182
git.repo.Repo.create(transport.local_abspath("."))
183
return self.open(transport)
184
185
186
bzrdir.BzrDirFormat.register_control_format(GitBzrDirFormat)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0