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 fetch.py
- browse files at revision 0.200.598
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.598
- Committer: Jelmer Vernooij
- Date: 2009-07-25 18:03:11 UTC
- 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-20090725180311-qh06fajtq85moxk4
Cope with ghosts.
- files added:
- HACKING
- files removed:
- foreign
- files renamed:
- converter.py => object_store.py
- tests/test_ids.py => tests/test_mapping.py
- files modified:
- README
added
removed
fetch.py
1
# Copyright (C) 2008 Canonical Ltd
1
# Copyright (C) 2008 Jelmer Vernooij <jelmer@samba.org>
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
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
23
17
from dulwich.objects import (
18
Commit,
19
Tag,
20
S_ISGITLINK,
21
)
22
from dulwich.object_store import (
23
tree_lookup_path,
24
)
25
import re
26
import stat
27
28
from bzrlib import (
29
debug,
30
osutils,
31
trace,
32
ui,
33
urlutils,
34
)
35
from bzrlib.errors import (
36
NoSuchId,
37
)
38
from bzrlib.inventory import (
39
Inventory,
40
InventoryDirectory,
41
InventoryFile,
42
InventoryLink,
43
)
44
from bzrlib.lru_cache import (
45
LRUCache,
46
)
47
from bzrlib.repository import (
48
InterRepository,
49
)
50
from bzrlib.revision import (
51
NULL_REVISION,
52
)
53
from bzrlib.tsort import (
54
topo_sort,
55
)
56
from bzrlib.versionedfile import (
57
FulltextContentFactory,
58
)
59
60
from bzrlib.plugins.git.mapping import (
61
DEFAULT_FILE_MODE,
62
inventory_to_tree_and_blobs,
63
mode_is_executable,
64
squash_revision,
65
warn_unusual_mode,
66
)
67
from bzrlib.plugins.git.object_store import (
68
BazaarObjectStore,
69
)
70
from bzrlib.plugins.git.remote import (
71
RemoteGitRepository,
72
)
24
73
from bzrlib.plugins.git.repository import (
25
LocalGitRepository,
26
GitRepository,
27
GitFormat,
28
)
29
from bzrlib.plugins.git.converter import GitObjectConverter
30
from bzrlib.plugins.git.remote import RemoteGitRepository
31
32
import dulwich as git
33
from dulwich.client import SimpleFetchGraphWalker
34
from dulwich.objects import Commit
35
36
from cStringIO import StringIO
37
38
39
class BzrFetchGraphWalker(object):
40
"""GraphWalker implementation that uses a Bazaar repository."""
41
42
def __init__(self, repository, mapping):
43
self.repository = repository
44
self.mapping = mapping
45
self.done = set()
46
self.heads = set(repository.all_revision_ids())
47
self.parents = {}
48
49
def __iter__(self):
50
return iter(self.next, None)
51
52
def ack(self, sha):
53
revid = self.mapping.revision_id_foreign_to_bzr(sha)
54
self.remove(revid)
55
56
def remove(self, revid):
57
self.done.add(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]:
62
self.remove(p)
63
64
def next(self):
65
while self.heads:
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])
70
try:
71
self.done.add(ret)
72
return self.mapping.revision_id_bzr_to_foreign(ret)[0]
73
except InvalidRevisionId:
74
pass
75
return None
76
77
78
def import_git_blob(repo, mapping, path, blob, inv, parent_invs, gitmap, executable):
74
GitRepository,
75
GitRepositoryFormat,
76
LocalGitRepository,
77
)
78
79
80
def import_git_blob(texts, mapping, path, hexsha, base_inv, base_ie, parent_id,
81
revision_id, parent_invs, shagitmap, lookup_object, executable, symlink):
79
82
"""Import a git blob object into a bzr repository.
80
83
81
:param repo: bzr repository
84
:param texts: VersionedFiles to add to
82
85
:param path: Path in the tree
83
86
:param blob: A git blob
87
:return: Inventory delta for this file
84
88
"""
85
89
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)
90
if symlink:
91
cls = InventoryLink
92
else:
93
cls = InventoryFile
94
# We just have to hope this is indeed utf-8:
95
ie = cls(file_id, urlutils.basename(path).decode("utf-8"), parent_id)
94
96
ie.executable = executable
95
gitmap._idmap.add_entry(blob.sha().hexdigest(), "blob", (ie.file_id, ie.revision))
96
97
98
def import_git_tree(repo, mapping, path, tree, inv, parent_invs,
99
gitmap, lookup_object):
97
# See if this has changed at all
98
if base_ie is None:
99
base_sha = None
100
else:
101
try:
102
base_sha = shagitmap.lookup_blob(file_id, base_ie.revision)
103
except KeyError:
104
base_sha = None
105
else:
106
if (base_sha == hexsha and base_ie.executable == ie.executable
107
and base_ie.kind == ie.kind):
108
# If nothing has changed since the base revision, we're done
109
return [], []
110
if base_sha == hexsha and base_ie.kind == ie.kind:
111
ie.text_size = base_ie.text_size
112
ie.text_sha1 = base_ie.text_sha1
113
ie.symlink_target = base_ie.symlink_target
114
if ie.executable == base_ie.executable:
115
ie.revision = base_ie.revision
116
else:
117
blob = lookup_object(hexsha)
118
else:
119
blob = lookup_object(hexsha)
120
if ie.kind == "symlink":
121
ie.revision = None
122
ie.symlink_target = blob.data
123
ie.text_size = None
124
ie.text_sha1 = None
125
else:
126
ie.text_size = len(blob.data)
127
ie.text_sha1 = osutils.sha_string(blob.data)
128
# Check what revision we should store
129
parent_keys = []
130
for pinv in parent_invs:
131
if pinv.revision_id == base_inv.revision_id:
132
pie = base_ie
133
if pie is None:
134
continue
135
else:
136
try:
137
pie = pinv[file_id]
138
except NoSuchId:
139
continue
140
if pie.text_sha1 == ie.text_sha1 and pie.executable == ie.executable and pie.symlink_target == ie.symlink_target:
141
# found a revision in one of the parents to use
142
ie.revision = pie.revision
143
break
144
parent_keys.append((file_id, pie.revision))
145
if ie.revision is None:
146
# Need to store a new revision
147
ie.revision = revision_id
148
assert file_id is not None
149
assert ie.revision is not None
150
texts.insert_record_stream([FulltextContentFactory((file_id, ie.revision), tuple(parent_keys), ie.text_sha1, blob.data)])
151
shamap = [(hexsha, "blob", (ie.file_id, ie.revision))]
152
else:
153
shamap = []
154
invdelta = []
155
if base_ie is not None:
156
old_path = base_inv.id2path(file_id)
157
if base_ie.kind == "directory":
158
invdelta.extend(remove_disappeared_children(old_path, base_ie.children, []))
159
else:
160
old_path = None
161
invdelta.append((old_path, path, file_id, ie))
162
return (invdelta, shamap)
163
164
165
def import_git_submodule(texts, mapping, path, hexsha, base_inv, base_ie, parent_id,
166
revision_id, parent_invs, shagitmap, lookup_object):
167
raise NotImplementedError(import_git_submodule)
168
169
170
def remove_disappeared_children(path, base_children, existing_children):
171
ret = []
172
deletable = [(osutils.pathjoin(path, k), v) for k,v in base_children.iteritems() if k not in existing_children]
173
while deletable:
174
(path, ie) = deletable.pop()
175
ret.append((path, None, ie.file_id, None))
176
if ie.kind == "directory":
177
for name, child_ie in ie.children.iteritems():
178
deletable.append((osutils.pathjoin(path, name), child_ie))
179
return ret
180
181
182
def import_git_tree(texts, mapping, path, hexsha, base_inv, base_ie, parent_id,
183
revision_id, parent_invs, shagitmap, lookup_object):
100
184
"""Import a git tree object into a bzr repository.
101
185
102
:param repo: A Bzr repository object
186
:param texts: VersionedFiles object to add to
103
187
:param path: Path in the tree
104
188
:param tree: A git tree object
105
:param inv: Inventory object
189
:param base_inv: Base inventory against which to return inventory delta
190
:return: Inventory delta for this subtree
106
191
"""
192
invdelta = []
107
193
file_id = mapping.generate_file_id(path)
108
text_revision = inv.revision_id
109
repo.texts.add_lines((file_id, text_revision),
110
[(file_id, p[file_id].revision) for p in parent_invs if file_id in p],
111
[])
112
ie = inv.add_path(path, "directory", file_id)
113
ie.revision = text_revision
114
gitmap._idmap.add_entry(tree.sha().hexdigest(), "tree", (file_id, text_revision))
115
for mode, name, hexsha in tree.entries():
116
entry_kind = (mode & 0700000) / 0100000
194
# We just have to hope this is indeed utf-8:
195
ie = InventoryDirectory(file_id, urlutils.basename(path.decode("utf-8")),
196
parent_id)
197
if base_ie is None:
198
# Newly appeared here
199
ie.revision = revision_id
200
texts.insert_record_stream([FulltextContentFactory((file_id, ie.revision), (), None, "")])
201
invdelta.append((None, path, file_id, ie))
202
else:
203
# See if this has changed at all
204
try:
205
base_sha = shagitmap.lookup_tree(file_id, base_inv.revision_id)
206
except KeyError:
207
pass
208
else:
209
if base_sha == hexsha:
210
# If nothing has changed since the base revision, we're done
211
return [], {}, []
212
if base_ie.kind != "directory":
213
ie.revision = revision_id
214
texts.insert_record_stream([FulltextContentFactory((ie.file_id, ie.revision), (), None, "")])
215
invdelta.append((base_inv.id2path(ie.file_id), path, ie.file_id, ie))
216
if base_ie is not None and base_ie.kind == "directory":
217
base_children = base_ie.children
218
else:
219
base_children = {}
220
# Remember for next time
221
existing_children = set()
222
child_modes = {}
223
shamap = []
224
tree = lookup_object(hexsha)
225
for mode, name, child_hexsha in tree.entries():
117
226
basename = name.decode("utf-8")
118
if path == "":
119
child_path = name
120
else:
121
child_path = urlutils.join(path, name)
122
if entry_kind == 0:
123
tree = lookup_object(hexsha)
124
import_git_tree(repo, mapping, child_path, tree, inv, parent_invs, gitmap, lookup_object)
125
elif entry_kind == 1:
126
blob = lookup_object(hexsha)
127
fs_mode = mode & 0777
128
import_git_blob(repo, mapping, child_path, blob, inv, parent_invs, gitmap, bool(fs_mode & 0111))
129
else:
130
raise AssertionError("Unknown blob kind, perms=%r." % (mode,))
227
existing_children.add(basename)
228
child_path = osutils.pathjoin(path, name)
229
if stat.S_ISDIR(mode):
230
subinvdelta, grandchildmodes, subshamap = import_git_tree(
231
texts, mapping, child_path, child_hexsha, base_inv,
232
base_children.get(basename), file_id, revision_id, parent_invs, shagitmap,
233
lookup_object)
234
invdelta.extend(subinvdelta)
235
child_modes.update(grandchildmodes)
236
shamap.extend(subshamap)
237
elif S_ISGITLINK(mode): # submodule
238
subinvdelta, grandchildmodes, subshamap = import_git_submodule(
239
texts, mapping, child_path, child_hexsha, base_inv, base_children.get(basename),
240
file_id, revision_id, parent_invs, shagitmap, lookup_object)
241
invdelta.extend(subinvdelta)
242
child_modes.update(grandchildmodes)
243
shamap.extend(subshamap)
244
else:
245
subinvdelta, subshamap = import_git_blob(texts, mapping,
246
child_path, child_hexsha, base_inv, base_children.get(basename), file_id,
247
revision_id, parent_invs, shagitmap, lookup_object,
248
mode_is_executable(mode), stat.S_ISLNK(mode))
249
invdelta.extend(subinvdelta)
250
shamap.extend(subshamap)
251
if mode not in (stat.S_IFDIR, DEFAULT_FILE_MODE,
252
stat.S_IFLNK, DEFAULT_FILE_MODE|0111):
253
child_modes[child_path] = mode
254
# Remove any children that have disappeared
255
if base_ie is not None and base_ie.kind == "directory":
256
invdelta.extend(remove_disappeared_children(base_inv.id2path(file_id),
257
base_children, existing_children))
258
shamap.append((hexsha, "tree", (file_id, revision_id)))
259
return invdelta, child_modes, shamap
131
260
132
261
133
262
def import_git_objects(repo, mapping, object_iter, target_git_object_retriever,
134
pb=None):
263
heads, pb=None):
135
264
"""Import a set of git objects into a bzr repository.
136
265
137
:param repo: Bazaar repository
266
:param repo: Target Bazaar repository
138
267
:param mapping: Mapping to use
139
268
:param object_iter: Iterator over Git objects.
140
269
"""
270
def lookup_object(sha):
271
try:
272
return object_iter[sha]
273
except KeyError:
274
return target_git_object_retriever[sha]
141
275
# TODO: a more (memory-)efficient implementation of this
142
276
graph = []
143
277
root_trees = {}
144
278
revisions = {}
279
checked = set()
280
heads = list(heads)
281
parent_invs_cache = LRUCache(50)
145
282
# Find and convert commit objects
146
for o in object_iter.iterobjects():
283
while heads:
284
if pb is not None:
285
pb.update("finding revisions to fetch", len(graph), None)
286
head = heads.pop()
287
assert isinstance(head, str)
288
try:
289
o = lookup_object(head)
290
except KeyError:
291
trace.mutter('missing head %s', head)
292
continue
147
293
if isinstance(o, Commit):
148
294
rev = mapping.import_commit(o)
149
root_trees[rev.revision_id] = object_iter[o.tree]
295
if repo.has_revision(rev.revision_id):
296
continue
297
squash_revision(repo, rev)
298
root_trees[rev.revision_id] = o.tree
150
299
revisions[rev.revision_id] = rev
151
300
graph.append((rev.revision_id, rev.parent_ids))
152
target_git_object_retriever._idmap.add_entry(o.sha().hexdigest(), "commit", (rev.revision_id, o._tree))
301
target_git_object_retriever._idmap.add_entry(o.id, "commit",
302
(rev.revision_id, o.tree))
303
heads.extend([p for p in o.parents if p not in checked])
304
elif isinstance(o, Tag):
305
heads.append(o.object[1])
306
else:
307
trace.warning("Unable to import head object %r" % o)
308
checked.add(head)
153
309
# Order the revisions
154
310
# Create the inventory objects
155
311
for i, revid in enumerate(topo_sort(graph)):
156
312
if pb is not None:
157
313
pb.update("fetching revisions", i, len(graph))
158
root_tree = root_trees[revid]
159
314
rev = revisions[revid]
160
315
# We have to do this here, since we have to walk the tree and
161
# we need to make sure to import the blobs / trees with the riht
316
# we need to make sure to import the blobs / trees with the right
162
317
# path; this may involve adding them more than once.
163
inv = Inventory()
164
inv.revision_id = rev.revision_id
165
def lookup_object(sha):
166
if sha in object_iter:
167
return object_iter[sha]
168
return target_git_object_retriever[sha]
169
parent_invs = [repo.get_inventory(r) for r in rev.parent_ids]
170
import_git_tree(repo, mapping, "", root_tree, inv, parent_invs,
171
target_git_object_retriever, lookup_object)
172
repo.add_revision(rev.revision_id, rev, inv)
173
174
175
class InterGitNonGitRepository(InterRepository):
176
177
_matching_repo_format = GitFormat()
318
parent_invs = []
319
for parent_id in rev.parent_ids:
320
try:
321
parent_invs.append(parent_invs_cache[parent_id])
322
except KeyError:
323
parent_inv = repo.get_inventory(parent_id)
324
parent_invs.append(parent_inv)
325
parent_invs_cache[parent_id] = parent_inv
326
if parent_invs == []:
327
base_inv = Inventory(root_id=None)
328
base_ie = None
329
else:
330
base_inv = parent_invs[0]
331
base_ie = base_inv.root
332
inv_delta, unusual_modes, shamap = import_git_tree(repo.texts,
333
mapping, "", root_trees[revid], base_inv, base_ie, None, revid,
334
parent_invs, target_git_object_retriever._idmap, lookup_object)
335
target_git_object_retriever._idmap.add_entries(shamap)
336
if unusual_modes != {}:
337
for path, mode in unusual_modes.iteritems():
338
warn_unusual_mode(rev.foreign_revid, path, mode)
339
mapping.import_unusual_file_modes(rev, unusual_modes)
340
try:
341
basis_id = rev.parent_ids[0]
342
except IndexError:
343
basis_id = NULL_REVISION
344
rev.inventory_sha1, inv = repo.add_inventory_by_delta(basis_id,
345
inv_delta, rev.revision_id, rev.parent_ids)
346
parent_invs_cache[rev.revision_id] = inv
347
repo.add_revision(rev.revision_id, rev)
348
if "verify" in debug.debug_flags:
349
new_unusual_modes = mapping.export_unusual_file_modes(rev)
350
if new_unusual_modes != unusual_modes:
351
raise AssertionError("unusual modes don't match: %r != %r" % (unusual_modes, new_unusual_modes))
352
objs = inventory_to_tree_and_blobs(inv, repo.texts, mapping, unusual_modes)
353
for sha1, newobj, path in objs:
354
assert path is not None
355
oldobj = tree_lookup_path(lookup_object, root_trees[revid], path)
356
if oldobj != newobj:
357
raise AssertionError("%r != %r in %s" % (oldobj, newobj, path))
358
359
target_git_object_retriever._idmap.commit()
360
361
362
class InterGitRepository(InterRepository):
363
364
_matching_repo_format = GitRepositoryFormat()
178
365
179
366
@staticmethod
180
367
def _get_repo_format_to_test():
184
371
"""See InterRepository.copy_content."""
185
372
self.fetch(revision_id, pb, find_ghosts=False)
186
373
374
def fetch(self, revision_id=None, pb=None, find_ghosts=False, mapping=None,
375
fetch_spec=None):
376
self.fetch_refs(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts,
377
mapping=mapping, fetch_spec=fetch_spec)
378
379
380
class InterGitNonGitRepository(InterGitRepository):
381
"""Base InterRepository that copies revisions from a Git into a non-Git
382
repository."""
383
384
def fetch_refs(self, revision_id=None, pb=None, find_ghosts=False,
385
mapping=None, fetch_spec=None):
386
if mapping is None:
387
mapping = self.source.get_mapping()
388
if revision_id is not None:
389
interesting_heads = [revision_id]
390
elif fetch_spec is not None:
391
interesting_heads = fetch_spec.heads
392
else:
393
interesting_heads = None
394
self._refs = {}
395
def determine_wants(refs):
396
self._refs = refs
397
if interesting_heads is None:
398
ret = [sha for (ref, sha) in refs.iteritems() if not ref.endswith("^{}")]
399
else:
400
ret = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in interesting_heads if revid not in (None, NULL_REVISION)]
401
return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
402
pack_hint = self.fetch_objects(determine_wants, mapping, pb)
403
if pack_hint is not None and self.target._format.pack_compresses:
404
self.target.pack(hint=pack_hint)
405
if interesting_heads is not None:
406
present_interesting_heads = self.target.has_revisions(interesting_heads)
407
missing_interesting_heads = set(interesting_heads) - present_interesting_heads
408
if missing_interesting_heads:
409
raise AssertionError("Missing interesting heads: %r" % missing_interesting_heads)
410
return self._refs
411
412
413
_GIT_PROGRESS_RE = re.compile(r"(.*?): +(\d+)% \((\d+)/(\d+)\)")
414
def report_git_progress(pb, text):
415
text = text.rstrip("\r\n")
416
g = _GIT_PROGRESS_RE.match(text)
417
if g is not None:
418
(text, pct, current, total) = g.groups()
419
pb.update(text, int(current), int(total))
420
else:
421
pb.update(text, 0, 0)
422
423
424
class InterRemoteGitNonGitRepository(InterGitNonGitRepository):
425
"""InterRepository that copies revisions from a remote Git into a non-Git
426
repository."""
427
428
def get_target_heads(self):
429
# FIXME: This should be more efficient
430
all_revs = self.target.all_revision_ids()
431
parent_map = self.target.get_parent_map(all_revs)
432
all_parents = set()
433
map(all_parents.update, parent_map.itervalues())
434
return set(all_revs) - all_parents
435
187
436
def fetch_objects(self, determine_wants, mapping, pb=None):
188
437
def progress(text):
189
pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
190
graph_walker = BzrFetchGraphWalker(self.target, mapping)
438
report_git_progress(pb, text)
439
store = BazaarObjectStore(self.target, mapping)
440
self.target.lock_write()
441
try:
442
heads = self.get_target_heads()
443
graph_walker = store.get_graph_walker(
444
[store._lookup_revision_sha1(head) for head in heads])
445
recorded_wants = []
446
447
def record_determine_wants(heads):
448
wants = determine_wants(heads)
449
recorded_wants.extend(wants)
450
return wants
451
452
create_pb = None
453
if pb is None:
454
create_pb = pb = ui.ui_factory.nested_progress_bar()
455
try:
456
self.target.start_write_group()
457
try:
458
objects_iter = self.source.fetch_objects(
459
record_determine_wants, graph_walker,
460
store.get_raw, progress)
461
import_git_objects(self.target, mapping, objects_iter,
462
store, recorded_wants, pb)
463
finally:
464
pack_hint = self.target.commit_write_group()
465
return pack_hint
466
finally:
467
if create_pb:
468
create_pb.finished()
469
finally:
470
self.target.unlock()
471
472
@staticmethod
473
def is_compatible(source, target):
474
"""Be compatible with GitRepository."""
475
# FIXME: Also check target uses VersionedFile
476
return (isinstance(source, RemoteGitRepository) and
477
target.supports_rich_root() and
478
not isinstance(target, GitRepository))
479
480
481
class InterLocalGitNonGitRepository(InterGitNonGitRepository):
482
"""InterRepository that copies revisions from a local Git into a non-Git
483
repository."""
484
485
def fetch_objects(self, determine_wants, mapping, pb=None):
486
wants = determine_wants(self.source._git.get_refs())
191
487
create_pb = None
192
488
if pb is None:
193
489
create_pb = pb = ui.ui_factory.nested_progress_bar()
194
target_git_object_retriever = GitObjectConverter(self.target, mapping)
195
490
target_git_object_retriever = BazaarObjectStore(self.target, mapping)
196
491
try:
197
492
self.target.lock_write()
198
493
try:
199
494
self.target.start_write_group()
200
495
try:
201
objects_iter = self.source.fetch_objects(determine_wants,
202
graph_walker,
203
target_git_object_retriever.__getitem__,
204
progress)
205
import_git_objects(self.target, mapping, objects_iter,
206
target_git_object_retriever, pb)
496
import_git_objects(self.target, mapping,
497
self.source._git.object_store,
498
target_git_object_retriever, wants, pb)
207
499
finally:
208
self.target.commit_write_group()
500
pack_hint = self.target.commit_write_group()
501
return pack_hint
209
502
finally:
210
503
self.target.unlock()
211
504
finally:
212
505
if create_pb:
213
506
create_pb.finished()
214
507
215
def fetch(self, revision_id=None, pb=None, find_ghosts=False,
216
mapping=None):
217
if mapping is None:
218
mapping = self.source.get_mapping()
219
def determine_wants(heads):
220
if revision_id is None:
221
ret = heads.values()
222
else:
223
ret = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
224
return [rev for rev in ret if not self.target.has_revision(mapping.revision_id_foreign_to_bzr(rev))]
225
return self.fetch_objects(determine_wants, mapping, pb)
226
227
508
@staticmethod
228
509
def is_compatible(source, target):
229
510
"""Be compatible with GitRepository."""
230
511
# FIXME: Also check target uses VersionedFile
231
return (isinstance(source, GitRepository) and
512
return (isinstance(source, LocalGitRepository) and
232
513
target.supports_rich_root() and
233
514
not isinstance(target, GitRepository))
234
515
235
516
236
class InterGitRepository(InterRepository):
237
238
_matching_repo_format = GitFormat()
239
240
@staticmethod
241
def _get_repo_format_to_test():
242
return None
243
244
def copy_content(self, revision_id=None, pb=None):
245
"""See InterRepository.copy_content."""
246
self.fetch(revision_id, pb, find_ghosts=False)
247
248
def fetch(self, revision_id=None, pb=None, find_ghosts=False,
249
mapping=None):
517
class InterGitGitRepository(InterGitRepository):
518
"""InterRepository that copies between Git repositories."""
519
520
def fetch_refs(self, revision_id=None, pb=None, find_ghosts=False,
521
mapping=None, fetch_spec=None, branches=None):
250
522
if mapping is None:
251
523
mapping = self.source.get_mapping()
252
524
def progress(text):
253
info("git: %s", text)
525
trace.info("git: %s", text)
254
526
r = self.target._git
255
if revision_id is None:
256
determine_wants = lambda x: [y for y in x.values() if not y in r.object_store]
257
else:
527
if revision_id is not None:
258
528
args = [mapping.revision_id_bzr_to_foreign(revision_id)[0]]
529
elif fetch_spec is not None:
530
args = [mapping.revision_id_bzr_to_foreign(revid)[0] for revid in fetch_spec.heads]
531
if branches is not None:
532
determine_wants = lambda x: [x[y] for y in branches if not x[y] in r.object_store]
533
elif fetch_spec is None and revision_id is None:
534
determine_wants = r.object_store.determine_wants_all
535
else:
259
536
determine_wants = lambda x: [y for y in args if not y in r.object_store]
260
537
261
graphwalker = SimpleFetchGraphWalker(r.heads().values(), r.get_parents)
262
f, commit = r.object_store.add_pack()
538
graphwalker = r.get_graph_walker()
539
f, commit = r.object_store.add_thin_pack()
263
540
try:
264
self.source._git.fetch_pack(path, determine_wants, graphwalker, f.write, progress)
265
f.close()
541
refs = self.source.fetch_pack(determine_wants, graphwalker,
542
f.write, progress)
266
543
commit()
544
return refs
267
545
except:
268
546
f.close()
269
547
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0