1
# Copyright (C) 2008 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
from bzrlib import osutils, ui, urlutils
18
from bzrlib.errors import InvalidRevisionId, NoSuchRevision
19
from bzrlib.inventory import Inventory
20
from bzrlib.repository import InterRepository
21
from bzrlib.trace import info
22
from bzrlib.tsort import topo_sort
24
from bzrlib.plugins.git.repository import (
29
from bzrlib.plugins.git.shamap import GitObjectConverter
30
from bzrlib.plugins.git.remote import RemoteGitRepository
33
from dulwich.client import SimpleFetchGraphWalker
34
from dulwich.objects import Commit
36
from cStringIO import StringIO
39
class BzrFetchGraphWalker(object):
40
"""GraphWalker implementation that uses a Bazaar repository."""
42
def __init__(self, repository, mapping):
43
self.repository = repository
44
self.mapping = mapping
46
self.heads = set(repository.all_revision_ids())
50
return iter(self.next, None)
53
revid = self.mapping.revision_id_foreign_to_bzr(sha)
56
def remove(self, revid):
58
if revid in self.heads:
59
self.heads.remove(revid)
60
if revid in self.parents:
61
for p in self.parents[revid]:
66
ret = self.heads.pop()
67
ps = self.repository.get_parent_map([ret])[ret]
68
self.parents[ret] = ps
69
self.heads.update([p for p in ps if not p in self.done])
72
return self.mapping.revision_id_bzr_to_foreign(ret)[0]
73
except InvalidRevisionId:
78
def import_git_blob(repo, mapping, path, blob, inv, parent_invs, executable):
79
"""Import a git blob object into a bzr repository.
81
:param repo: bzr repository
82
:param path: Path in the tree
83
:param blob: A git blob
85
file_id = mapping.generate_file_id(path)
86
text_revision = inv.revision_id
87
repo.texts.add_lines((file_id, text_revision),
88
[(file_id, p[file_id].revision) for p in parent_invs if file_id in p],
89
osutils.split_lines(blob.data))
90
ie = inv.add_path(path, "file", file_id)
91
ie.revision = text_revision
92
ie.text_size = len(blob.data)
93
ie.text_sha1 = osutils.sha_string(blob.data)
94
ie.executable = executable
97
def import_git_tree(repo, mapping, path, tree, inv, parent_invs, lookup_object):
98
"""Import a git tree object into a bzr repository.
100
:param repo: A Bzr repository object
101
:param path: Path in the tree
102
:param tree: A git tree object
103
:param inv: Inventory object
105
file_id = mapping.generate_file_id(path)
106
text_revision = inv.revision_id
107
repo.texts.add_lines((file_id, text_revision),
108
[(file_id, p[file_id].revision) for p in parent_invs if file_id in p],
110
ie = inv.add_path(path, "directory", file_id)
111
ie.revision = text_revision
112
for mode, name, hexsha in tree.entries():
113
entry_kind = (mode & 0700000) / 0100000
114
basename = name.decode("utf-8")
118
child_path = urlutils.join(path, name)
120
tree = lookup_object(hexsha)
121
import_git_tree(repo, mapping, child_path, tree, inv, parent_invs, lookup_object)
122
elif entry_kind == 1:
123
blob = lookup_object(hexsha)
124
fs_mode = mode & 0777
125
import_git_blob(repo, mapping, child_path, blob, inv, parent_invs, bool(fs_mode & 0111))
127
raise AssertionError("Unknown blob kind, perms=%r." % (mode,))
130
def import_git_objects(repo, mapping, object_iter, target_git_object_retriever,
132
"""Import a set of git objects into a bzr repository.
134
:param repo: Bazaar repository
135
:param mapping: Mapping to use
136
:param object_iter: Iterator over Git objects.
138
# TODO: a more (memory-)efficient implementation of this
142
# Find and convert commit objects
143
for o in object_iter.iterobjects():
144
if isinstance(o, Commit):
145
rev = mapping.import_commit(o)
146
root_trees[rev.revision_id] = object_iter[o.tree]
147
revisions[rev.revision_id] = rev
148
graph.append((rev.revision_id, rev.parent_ids))
149
# Order the revisions
150
# Create the inventory objects
151
for i, revid in enumerate(topo_sort(graph)):
153
pb.update("fetching revisions", i, len(graph))
154
root_tree = root_trees[revid]
155
rev = revisions[revid]
156
# We have to do this here, since we have to walk the tree and
157
# we need to make sure to import the blobs / trees with the riht
158
# path; this may involve adding them more than once.
160
inv.revision_id = rev.revision_id
161
def lookup_object(sha):
162
if sha in object_iter:
163
return object_iter[sha]
164
return target_git_object_retriever(sha)
165
parent_invs = [repo.get_inventory(r) for r in rev.parent_ids]
166
import_git_tree(repo, mapping, "", root_tree, inv, parent_invs,
168
repo.add_revision(rev.revision_id, rev, inv)
171
def reconstruct_git_object(repo, mapping, sha):
172
import pdb; pdb.set_trace()
176
raise KeyError("No such object %s" % sha)
179
class InterGitNonGitRepository(InterRepository):
181
_matching_repo_format = GitFormat()
184
def _get_repo_format_to_test():
187
def copy_content(self, revision_id=None, pb=None):
188
"""See InterRepository.copy_content."""
189
self.fetch(revision_id, pb, find_ghosts=False)
191
def fetch_objects(self, determine_wants, mapping, pb=None):
193
pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
194
graph_walker = BzrFetchGraphWalker(self.target, mapping)
197
create_pb = pb = ui.ui_factory.nested_progress_bar()
198
target_git_object_retriever = GitObjectConverter(self.target, mapping)
201
self.target.lock_write()
203
self.target.start_write_group()
205
objects_iter = self.source.fetch_objects(determine_wants,
207
target_git_object_retriever.__getitem__,
209
import_git_objects(self.target, mapping, objects_iter,
210
target_git_object_retriever, pb)
212
self.target.commit_write_group()
219
def fetch(self, revision_id=None, pb=None, find_ghosts=False,
222
mapping = self.source.get_mapping()
223
def determine_wants(heads):
224
if revision_id is None:
227
ret = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
228
return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
229
return self.fetch_objects(determine_wants, mapping, pb)
232
def is_compatible(source, target):
233
"""Be compatible with GitRepository."""
234
# FIXME: Also check target uses VersionedFile
235
return (isinstance(source, GitRepository) and
236
target.supports_rich_root() and
237
not isinstance(target, GitRepository))
240
class InterGitRepository(InterRepository):
242
_matching_repo_format = GitFormat()
245
def _get_repo_format_to_test():
248
def copy_content(self, revision_id=None, pb=None):
249
"""See InterRepository.copy_content."""
250
self.fetch(revision_id, pb, find_ghosts=False)
252
def fetch(self, revision_id=None, pb=None, find_ghosts=False,
255
mapping = self.source.get_mapping()
257
info("git: %s", text)
259
if revision_id is None:
260
determine_wants = lambda x: [y for y in x.values() if not y in r.object_store]
262
args = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
263
determine_wants = lambda x: [y for y in args if not y in r.object_store]
265
graphwalker = SimpleFetchGraphWalker(r.heads().values(), r.get_parents)
266
f, commit = r.object_store.add_pack()
268
self.source._git.fetch_pack(path, determine_wants, graphwalker, f.write, progress)
276
def is_compatible(source, target):
277
"""Be compatible with GitRepository."""
278
return (isinstance(source, GitRepository) and
279
isinstance(target, GitRepository))
added
removed
fetch.py
