18
17
"""An adapter between a Git Repository and a Bazaar Branch"""
20
23
from bzrlib import (
27
35
from bzrlib.foreign import (
31
from bzrlib.plugins.git.commit import (
34
from bzrlib.plugins.git.mapping import (
39
from bzrlib.plugins.git.tree import (
42
from bzrlib.plugins.git.versionedfiles import (
48
from dulwich.objects import (
39
from bzrlib.trace import mutter
40
from bzrlib.transport import get_transport
42
from bzrlib.plugins.git.foreign import (
45
from bzrlib.plugins.git.mapping import default_mapping
47
from bzrlib.plugins.git import git
50
class GitTags(object):
52
def __init__(self, tags):
56
return iter(self._tags)
53
59
class GitRepository(ForeignRepository):
54
60
"""An adapter to git repositories for bzr."""
57
_commit_builder_class = GitCommitBuilder
60
64
def __init__(self, gitdir, lockfiles):
61
ForeignRepository.__init__(self, GitRepositoryFormat(), gitdir,
63
from bzrlib.plugins.git import fetch, push
64
for optimiser in [fetch.InterRemoteGitNonGitRepository,
65
fetch.InterLocalGitNonGitRepository,
66
fetch.InterGitGitRepository,
67
push.InterToLocalGitRepository,
68
push.InterToRemoteGitRepository]:
69
repository.InterRepository.register_optimiser(optimiser)
65
ForeignRepository.__init__(self, GitFormat(), gitdir, lockfiles)
66
from bzrlib.plugins.git import fetch
67
repository.InterRepository.register_optimiser(fetch.InterFromGitRepository)
71
69
def is_shared(self):
74
72
def supports_rich_root(self):
77
def _warn_if_deprecated(self, branch=None):
75
def _warn_if_deprecated(self):
78
76
# This class isn't deprecated
81
79
def get_mapping(self):
82
80
return default_mapping
84
def make_working_trees(self):
85
return not self._git.bare
87
def revision_graph_can_have_wrong_parents(self):
90
def dfetch(self, source, stop_revision):
91
interrepo = repository.InterRepository.get(source, self)
92
return interrepo.dfetch(stop_revision)
95
84
class LocalGitRepository(GitRepository):
96
"""Git repository on the file system."""
98
86
def __init__(self, gitdir, lockfiles):
87
# FIXME: This also caches negatives. Need to be more careful
88
# about this once we start writing to git
89
self._parents_provider = graph.CachingParentsProvider(self)
99
90
GitRepository.__init__(self, gitdir, lockfiles)
100
91
self.base = gitdir.root_transport.base
101
92
self._git = gitdir._git
102
self.signatures = None
103
self.revisions = GitRevisions(self, self._git.object_store)
104
self.inventories = None
105
self.texts = GitTexts(self)
107
def _iter_revision_ids(self):
108
mapping = self.get_mapping()
109
for sha in self._git.object_store:
110
o = self._git.object_store[sha]
111
if not isinstance(o, Commit):
113
rev, roundtrip_revid, verifiers = mapping.import_commit(o,
114
self.lookup_foreign_revision_id)
115
yield o.id, rev.revision_id, roundtrip_revid
94
self.signatures = versionedfiles.VirtualSignatureTexts(self)
95
self.revisions = versionedfiles.VirtualRevisionTexts(self)
96
self.tags = GitTags(self._git.get_tags())
117
98
def all_revision_ids(self):
119
for git_sha, revid, roundtrip_revid in self._iter_revision_ids():
122
ret.add(roundtrip_revid)
99
ret = set([revision.NULL_REVISION])
100
if self._git.heads() == []:
102
bzr_heads = [self.get_mapping().revision_id_foreign_to_bzr(h) for h in self._git.heads()]
104
graph = self.get_graph()
105
for rev, parents in graph.iter_ancestry(bzr_heads):
109
#def get_revision_delta(self, revision_id):
110
# parent_revid = self.get_revision(revision_id).parent_ids[0]
111
# diff = self._git.diff(ids.convert_revision_id_bzr_to_git(parent_revid),
112
# ids.convert_revision_id_bzr_to_git(revision_id))
114
def _make_parents_provider(self):
115
"""See Repository._make_parents_provider()."""
116
return self._parents_provider
125
118
def get_parent_map(self, revids):
120
mutter("get_parent_map(%r)", revids)
127
121
for revision_id in revids:
128
122
assert isinstance(revision_id, str)
129
123
if revision_id == revision.NULL_REVISION:
130
124
parent_map[revision_id] = ()
132
hexsha, mapping = self.lookup_bzr_revision_id(revision_id)
134
commit = self._git[hexsha]
126
hexsha = self.lookup_git_revid(revision_id, self.get_mapping())
127
commit = self._git.commit(hexsha)
137
parent_map[revision_id] = [
138
self.lookup_foreign_revision_id(p, mapping)
139
for p in commit.parents]
131
parent_map[revision_id] = [self.get_mapping().revision_id_foreign_to_bzr(p) for p in commit.parents]
140
132
return parent_map
142
134
def get_ancestry(self, revision_id, topo_sorted=True):
143
135
"""See Repository.get_ancestry().
145
137
if revision_id is None:
146
return [None, revision.NULL_REVISION] + self._all_revision_ids()
138
return self._all_revision_ids()
147
139
assert isinstance(revision_id, str)
149
141
graph = self.get_graph()
150
142
for rev, parents in graph.iter_ancestry([revision_id]):
143
if rev == revision.NULL_REVISION:
151
145
ancestry.append(rev)
152
146
ancestry.reverse()
153
return [None] + ancestry
155
149
def get_signature_text(self, revision_id):
156
150
raise errors.NoSuchRevision(self, revision_id)
158
def pack(self, hint=None, clean_obsolete_packs=False):
159
self._git.object_store.pack_loose_objects()
161
def lookup_foreign_revision_id(self, foreign_revid, mapping=None):
152
def lookup_revision_id(self, revid):
162
153
"""Lookup a revision id.
155
:param revid: Bazaar revision id.
156
:return: Tuple with git revisionid and mapping.
165
assert type(foreign_revid) is str
167
mapping = self.get_mapping()
168
from dulwich.protocol import (
171
if foreign_revid == ZERO_SHA:
172
return revision.NULL_REVISION
173
commit = self._git[foreign_revid]
174
rev, roundtrip_revid, verifiers = mapping.import_commit(commit,
176
# FIXME: check testament before doing this?
178
return roundtrip_revid
180
return rev.revision_id
158
# Yes, this doesn't really work, but good enough as a stub
159
return osutils.sha(rev_id).hexdigest(), self.get_mapping()
182
161
def has_signature_for_revision_id(self, revision_id):
185
def lookup_bzr_revision_id(self, bzr_revid, mapping=None):
164
def lookup_git_revid(self, bzr_revid, mapping):
187
return mapping_registry.revision_id_bzr_to_foreign(bzr_revid)
166
return mapping.revision_id_bzr_to_foreign(bzr_revid)
188
167
except errors.InvalidRevisionId:
190
mapping = self.get_mapping()
192
return (self._git.refs[mapping.revid_as_refname(bzr_revid)],
195
# Update refs from Git commit objects
196
# FIXME: Hitting this a lot will be very inefficient...
197
for git_sha, revid, roundtrip_revid in self._iter_revision_ids():
198
if not roundtrip_revid:
200
refname = mapping.revid_as_refname(roundtrip_revid)
201
self._git.refs[refname] = git_sha
202
if roundtrip_revid == bzr_revid:
203
return git_sha, mapping
204
raise errors.NoSuchRevision(self, bzr_revid)
168
raise errors.NoSuchRevision(self, bzr_revid)
206
170
def get_revision(self, revision_id):
207
git_commit_id, mapping = self.lookup_bzr_revision_id(revision_id)
209
commit = self._git[git_commit_id]
171
git_commit_id = self.lookup_git_revid(revision_id, self.get_mapping())
172
commit = self._git.commit(git_commit_id)
173
# print "fetched revision:", git_commit_id
211
175
raise errors.NoSuchRevision(self, revision_id)
212
revision, roundtrip_revid, verifiers = mapping.import_commit(
213
commit, self.lookup_foreign_revision_id)
176
revision = self._parse_rev(commit, self.get_mapping())
214
177
assert revision is not None
215
# FIXME: check verifiers ?
217
revision.revision_id = roundtrip_revid
220
180
def has_revision(self, revision_id):
222
git_commit_id, mapping = self.lookup_bzr_revision_id(revision_id)
182
self.get_revision(revision_id)
223
183
except errors.NoSuchRevision:
225
return (git_commit_id in self._git)
227
def has_revisions(self, revision_ids):
228
return set(filter(self.has_revision, revision_ids))
230
188
def get_revisions(self, revids):
231
189
return [self.get_revision(r) for r in revids]
192
def _parse_rev(klass, commit, mapping):
193
"""Convert a git commit to a bzr revision.
195
:return: a `bzrlib.revision.Revision` object.
198
raise AssertionError("Commit object can't be None")
199
rev = ForeignRevision(commit.id, mapping, mapping.revision_id_foreign_to_bzr(commit.id))
200
rev.parent_ids = tuple([mapping.revision_id_foreign_to_bzr(p) for p in commit.parents])
201
rev.message = commit.message.decode("utf-8", "replace")
202
rev.committer = str(commit.committer).decode("utf-8", "replace")
203
if commit.committer != commit.author:
204
rev.properties['author'] = str(commit.author).decode("utf-8", "replace")
205
rev.timestamp = commit.commit_time
233
209
def revision_trees(self, revids):
234
210
for revid in revids:
235
211
yield self.revision_tree(revid)
237
213
def revision_tree(self, revision_id):
238
214
revision_id = revision.ensure_null(revision_id)
239
216
if revision_id == revision.NULL_REVISION:
240
217
inv = inventory.Inventory(root_id=None)
241
218
inv.revision_id = revision_id
242
219
return revisiontree.RevisionTree(self, inv, revision_id)
243
221
return GitRevisionTree(self, revision_id)
245
223
def get_inventory(self, revision_id):
249
227
def set_make_working_trees(self, trees):
252
def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref,
254
return self._git.fetch_objects(determine_wants, graph_walker, progress)
256
def _get_versioned_file_checker(self, text_key_references=None,
258
return GitVersionedFileChecker(self,
259
text_key_references=text_key_references, ancestors=ancestors)
262
class GitVersionedFileChecker(repository._VersionedFileChecker):
266
def _check_file_version_parents(self, texts, progress_bar):
270
class GitRepositoryFormat(repository.RepositoryFormat):
271
"""Git repository format."""
230
def fetch_pack(self, determine_wants, graph_walker, pack_data):
231
raise NotImplementedError(self.fetch_pack)
234
def escape_file_id(file_id):
235
return file_id.replace('_', '__').replace(' ', '_s')
238
def unescape_file_id(file_id):
239
return file_id.replace("_s", " ").replace("__", "_")
242
class GitRevisionTree(revisiontree.RevisionTree):
244
def __init__(self, repository, revision_id):
245
self._repository = repository
246
self.revision_id = revision_id
247
git_id = repository.lookup_git_revid(revision_id, repository.get_mapping())
248
self.tree = repository._git.commit(git_id).tree
249
self._inventory = inventory.Inventory(revision_id=revision_id)
250
self._inventory.root.revision = revision_id
251
self._build_inventory(self.tree, self._inventory.root, "")
253
def get_revision_id(self):
254
return self.revision_id
256
def get_file_text(self, file_id):
257
entry = self._inventory[file_id]
258
if entry.kind == 'directory': return ""
259
return self._repository._git.get_blob(entry.text_id).data
261
def _build_inventory(self, tree_id, ie, path):
262
assert isinstance(path, str)
263
tree = self._repository._git.tree(tree_id)
264
for mode, name, hexsha in tree.entries():
265
basename = name.decode("utf-8")
269
child_path = urlutils.join(path, name)
270
file_id = escape_file_id(child_path.encode('utf-8'))
271
entry_kind = (mode & 0700000) / 0100000
273
child_ie = inventory.InventoryDirectory(file_id, basename, ie.file_id)
274
elif entry_kind == 1:
275
file_kind = (mode & 070000) / 010000
276
b = self._repository._git.get_blob(hexsha)
278
child_ie = inventory.InventoryFile(file_id, basename, ie.file_id)
279
child_ie.text_sha1 = osutils.sha_string(b.data)
281
child_ie = inventory.InventoryLink(file_id, basename, ie.file_id)
282
child_ie.text_sha1 = osutils.sha_string("")
284
raise AssertionError(
285
"Unknown file kind, perms=%o." % (mode,))
286
child_ie.text_id = b.id
287
child_ie.text_size = len(b.data)
289
raise AssertionError(
290
"Unknown blob kind, perms=%r." % (mode,))
291
fs_mode = mode & 0777
292
child_ie.executable = bool(fs_mode & 0111)
293
child_ie.revision = self.revision_id
294
self._inventory.add(child_ie)
296
self._build_inventory(hexsha, child_ie, child_path)
299
class GitFormat(object):
273
301
supports_tree_reference = False
274
302
rich_root_data = True
added
removed
repository.py
