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 object_store.py
- browse files at revision 0.200.730
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.730
- Committer: Jelmer Vernooij
- Date: 2010-03-03 16:40:57 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-20100303164057-1i8b44wv0y38vn0q
Don't claim control directories can be accessed directly, always open the
branch itself.
branch itself.
- files removed:
- notes/git-serve.txt
- files modified:
- NEWS
added
removed
object_store.py
18
18
19
19
from dulwich.objects import (
20
20
Blob,
21
Tree,
22
21
sha_to_hex,
23
22
)
24
23
from dulwich.object_store import (
26
25
)
27
26
28
27
from bzrlib import (
28
debug,
29
29
errors,
30
lru_cache,
31
30
trace,
32
31
ui,
33
urlutils,
34
32
)
35
33
from bzrlib.revision import (
36
34
NULL_REVISION,
41
39
directory_to_tree,
42
40
extract_unusual_modes,
43
41
mapping_registry,
44
symlink_to_blob,
45
42
)
46
43
from bzrlib.plugins.git.shamap import (
47
from_repository as cache_from_repository,
44
SqliteGitShaMap,
45
TdbGitShaMap,
48
46
)
49
47
50
import posixpath
51
import stat
52
53
48
54
49
def get_object_store(repo, mapping=None):
55
50
git = getattr(repo, "_git", None)
58
53
return BazaarObjectStore(repo, mapping)
59
54
60
55
61
MAX_TREE_CACHE_SIZE = 50 * 1024 * 1024
62
63
64
class LRUTreeCache(object):
65
66
def __init__(self, repository):
67
def approx_tree_size(tree):
68
# Very rough estimate, 1k per inventory entry
69
return len(tree.inventory) * 1024
70
self.repository = repository
71
self._cache = lru_cache.LRUSizeCache(max_size=MAX_TREE_CACHE_SIZE,
72
after_cleanup_size=None, compute_size=approx_tree_size)
73
74
def revision_tree(self, revid):
75
try:
76
return self._cache[revid]
77
except KeyError:
78
tree = self.repository.revision_tree(revid)
79
self.add(tree)
80
return tree
81
82
def iter_revision_trees(self, revids):
83
trees = dict([(k, self._cache.get(k)) for k in revids])
84
for tree in self.repository.revision_trees(
85
[r for r, v in trees.iteritems() if v is None]):
86
trees[tree.get_revision_id()] = tree
87
self.add(tree)
88
return (trees[r] for r in revids)
89
90
def revision_trees(self, revids):
91
return list(self.iter_revision_trees(revids))
92
93
def add(self, tree):
94
self._cache.add(tree.get_revision_id(), tree)
95
96
97
def _find_missing_bzr_revids(get_parent_map, want, have):
98
"""Find the revisions that have to be pushed.
99
100
:param get_parent_map: Function that returns the parents for a sequence
101
of revisions.
102
:param want: Revisions the target wants
103
:param have: Revisions the target already has
104
:return: Set of revisions to fetch
105
"""
106
pending = want - have
107
processed = set()
108
todo = set()
109
while pending:
110
processed.update(pending)
111
next_map = get_parent_map(pending)
112
next_pending = set()
113
for item in next_map.iteritems():
114
if item[0] in have:
115
continue
116
todo.add(item[0])
117
next_pending.update(p for p in item[1] if p not in processed)
118
pending = next_pending
119
if NULL_REVISION in todo:
120
todo.remove(NULL_REVISION)
121
return todo
122
123
124
def _check_expected_sha(expected_sha, object):
125
"""Check whether an object matches an expected SHA.
126
127
:param expected_sha: None or expected SHA as either binary or as hex digest
128
:param object: Object to verify
129
"""
130
if expected_sha is None:
131
return
132
if len(expected_sha) == 40:
133
if expected_sha != object.sha().hexdigest():
134
raise AssertionError("Invalid sha for %r: %s" % (object,
135
expected_sha))
136
elif len(expected_sha) == 20:
137
if expected_sha != object.sha().digest():
138
raise AssertionError("Invalid sha for %r: %s" % (object,
139
sha_to_hex(expected_sha)))
140
else:
141
raise AssertionError("Unknown length %d for %r" % (len(expected_sha),
142
expected_sha))
143
144
145
def _tree_to_objects(tree, parent_trees, idmap, unusual_modes, dummy_file_name=None):
146
"""Iterate over the objects that were introduced in a revision.
147
148
:param idmap: id map
149
:param unusual_modes: Unusual file modes
150
:param dummy_file_name: File name to use for dummy files
151
in empty directories. None to skip empty directories
152
:return: Yields (path, object, ie) entries
153
"""
154
new_trees = {}
155
new_blobs = []
156
shamap = {}
157
try:
158
base_tree = parent_trees[0]
159
other_parent_trees = parent_trees[1:]
160
except IndexError:
161
base_tree = tree._repository.revision_tree(NULL_REVISION)
162
other_parent_trees = []
163
def find_unchanged_parent_ie(ie, parent_trees):
164
assert ie.kind in ("symlink", "file")
165
for ptree in parent_trees:
166
try:
167
pie = ptree.inventory[ie.file_id]
168
except errors.NoSuchId:
169
pass
170
else:
171
if (pie.text_sha1 == ie.text_sha1 and
172
pie.kind == ie.kind and
173
pie.symlink_target == ie.symlink_target):
174
return pie
175
raise KeyError
176
for (file_id, path, changed_content, versioned, parent, name, kind,
177
executable) in tree.iter_changes(base_tree):
178
if kind[1] == "file":
179
ie = tree.inventory[file_id]
180
if changed_content:
181
182
try:
183
pie = find_unchanged_parent_ie(ie, other_parent_trees)
184
except KeyError:
185
pass
186
else:
187
shamap[ie.file_id] = idmap.lookup_blob_id(
188
pie.file_id, pie.revision)
189
if not file_id in shamap:
190
new_blobs.append((path[1], ie))
191
new_trees[posixpath.dirname(path[1])] = parent[1]
192
elif kind[1] == "symlink":
193
ie = tree.inventory[file_id]
194
if changed_content:
195
blob = symlink_to_blob(ie)
196
shamap[file_id] = blob.id
197
try:
198
find_unchanged_parent_ie(ie, other_parent_trees)
199
except KeyError:
200
yield path[1], blob, ie
201
new_trees[posixpath.dirname(path[1])] = parent[1]
202
elif kind[1] not in (None, "directory"):
203
raise AssertionError(kind[1])
204
if path[0] is not None:
205
new_trees[posixpath.dirname(path[0])] = parent[0]
206
207
for (path, ie), chunks in tree.iter_files_bytes(
208
[(ie.file_id, (path, ie)) for (path, ie) in new_blobs]):
209
obj = Blob()
210
obj.chunked = chunks
211
yield path, obj, ie
212
shamap[ie.file_id] = obj.id
213
214
for path in unusual_modes:
215
parent_path = posixpath.dirname(path)
216
new_trees[parent_path] = tree.path2id(parent_path)
217
218
trees = {}
219
while new_trees:
220
items = new_trees.items()
221
new_trees = {}
222
for path, file_id in items:
223
try:
224
parent_id = tree.inventory[file_id].parent_id
225
except errors.NoSuchId:
226
# Directory was removed recursively perhaps ?
227
continue
228
if parent_id is not None:
229
parent_path = urlutils.dirname(path)
230
new_trees[parent_path] = parent_id
231
trees[path] = file_id
232
233
def ie_to_hexsha(ie):
234
try:
235
return shamap[ie.file_id]
236
except KeyError:
237
# FIXME: Should be the same as in parent
238
if ie.kind in ("file", "symlink"):
239
try:
240
return idmap.lookup_blob_id(ie.file_id, ie.revision)
241
except KeyError:
242
# no-change merge ?
243
blob = Blob()
244
blob.data = tree.get_file_text(ie.file_id)
245
return blob.id
246
elif ie.kind == "directory":
247
# Not all cache backends store the tree information,
248
# calculate again from scratch
249
ret = directory_to_tree(ie, ie_to_hexsha, unusual_modes,
250
dummy_file_name)
251
if ret is None:
252
return ret
253
return ret.id
254
else:
255
raise AssertionError
256
257
for path in sorted(trees.keys(), reverse=True):
258
ie = tree.inventory[trees[path]]
259
assert ie.kind == "directory"
260
obj = directory_to_tree(ie, ie_to_hexsha, unusual_modes,
261
dummy_file_name)
262
if obj is not None:
263
yield path, obj, ie
264
shamap[ie.file_id] = obj.id
265
266
267
56
class BazaarObjectStore(BaseObjectStore):
268
57
"""A Git-style object store backed onto a Bazaar repository."""
269
58
273
62
self.mapping = default_mapping
274
63
else:
275
64
self.mapping = mapping
276
self._cache = cache_from_repository(repository)
277
self._content_cache_types = ("tree")
278
self.start_write_group = self._cache.idmap.start_write_group
279
self.abort_write_group = self._cache.idmap.abort_write_group
280
self.commit_write_group = self._cache.idmap.commit_write_group
281
self.tree_cache = LRUTreeCache(self.repository)
65
self._idmap = SqliteGitShaMap.from_repository(repository)
282
66
283
67
def _update_sha_map(self, stop_revision=None):
284
68
graph = self.repository.get_graph()
286
70
heads = graph.heads(self.repository.all_revision_ids())
287
71
else:
288
72
heads = set([stop_revision])
289
missing_revids = self._cache.idmap.missing_revisions(heads)
73
missing_revids = self._idmap.missing_revisions(heads)
290
74
while heads:
291
75
parents = graph.get_parent_map(heads)
292
76
todo = set()
293
77
for p in parents.values():
294
78
todo.update([x for x in p if x not in missing_revids])
295
heads = self._cache.idmap.missing_revisions(todo)
79
heads = self._idmap.missing_revisions(todo)
296
80
missing_revids.update(heads)
297
81
if NULL_REVISION in missing_revids:
298
82
missing_revids.remove(NULL_REVISION)
299
missing_revids = self.repository.has_revisions(missing_revids)
300
if not missing_revids:
301
return
302
self.start_write_group()
83
pb = ui.ui_factory.nested_progress_bar()
303
84
try:
304
pb = ui.ui_factory.nested_progress_bar()
305
try:
306
for i, revid in enumerate(graph.iter_topo_order(missing_revids)):
307
trace.mutter('processing %r', revid)
308
pb.update("updating git map", i, len(missing_revids))
309
self._update_sha_map_revision(revid)
310
finally:
311
pb.finished()
312
except:
313
self.abort_write_group()
314
raise
315
else:
316
self.commit_write_group()
85
for i, revid in enumerate(graph.iter_topo_order(missing_revids)):
86
pb.update("updating git map", i, len(missing_revids))
87
self._update_sha_map_revision(revid)
88
finally:
89
pb.finished()
90
self._idmap.commit_write_group()
317
91
318
92
def __iter__(self):
319
93
self._update_sha_map()
320
return iter(self._cache.idmap.sha1s())
94
return iter(self._idmap.sha1s())
321
95
322
def _reconstruct_commit(self, rev, tree_sha, roundtrip):
96
def _revision_to_commit(self, rev, tree_sha):
323
97
def parent_lookup(revid):
324
98
try:
325
99
return self._lookup_revision_sha1(revid)
326
100
except errors.NoSuchRevision:
327
101
trace.warning("Ignoring ghost parent %s", revid)
328
102
return None
329
return self.mapping.export_commit(rev, tree_sha, parent_lookup,
330
roundtrip)
331
332
def _revision_to_objects(self, rev, tree, roundtrip):
333
"""Convert a revision to a set of git objects.
334
335
:param rev: Bazaar revision object
336
:param tree: Bazaar revision tree
337
:param roundtrip: Whether to roundtrip all Bazaar revision data
338
"""
103
return self.mapping.export_commit(rev, tree_sha, parent_lookup)
104
105
def _update_sha_map_revision(self, revid):
106
inv = self.repository.get_inventory(revid)
107
rev = self.repository.get_revision(revid)
339
108
unusual_modes = extract_unusual_modes(rev)
340
present_parents = self.repository.has_revisions(rev.parent_ids)
341
parent_trees = self.tree_cache.revision_trees(
342
[p for p in rev.parent_ids if p in present_parents])
343
root_tree = None
344
for path, obj, ie in _tree_to_objects(tree, parent_trees,
345
self._cache.idmap, unusual_modes, self.mapping.BZR_DUMMY_FILE):
346
if path == "":
347
root_tree = obj
348
root_ie = ie
349
# Don't yield just yet
350
else:
351
yield path, obj, ie
352
if root_tree is None:
353
# Pointless commit - get the tree sha elsewhere
354
if not rev.parent_ids:
355
root_tree = Tree()
356
else:
357
base_sha1 = self._lookup_revision_sha1(rev.parent_ids[0])
358
root_tree = self[base_sha1]
359
root_ie = tree.inventory.root
360
if roundtrip:
361
# FIXME: This can probably be a lot more efficient,
362
# not all files necessarily have to be processed.
363
file_ids = {}
364
for (path, ie) in tree.inventory.iter_entries():
365
if self.mapping.generate_file_id(path) != ie.file_id:
366
file_ids[path] = ie.file_id
367
b = self.mapping.export_fileid_map(file_ids)
368
if b is not None:
369
root_tree[self.mapping.BZR_FILE_IDS_FILE] = ((stat.S_IFREG | 0644), b.id)
370
yield self.mapping.BZR_FILE_IDS_FILE, b, None
371
yield "", root_tree, root_ie
372
commit_obj = self._reconstruct_commit(rev, root_tree.id, roundtrip=roundtrip)
109
tree_sha = self._get_ie_sha1(inv.root, inv, unusual_modes)
110
commit_obj = self._revision_to_commit(rev, tree_sha)
373
111
try:
374
foreign_revid, mapping = mapping_registry.parse_revision_id(
375
rev.revision_id)
112
foreign_revid, mapping = mapping_registry.parse_revision_id(revid)
376
113
except errors.InvalidRevisionId:
377
114
pass
378
115
else:
379
_check_expected_sha(foreign_revid, commit_obj)
380
yield None, commit_obj, None
381
382
def _get_updater(self, rev):
383
return self._cache.get_updater(rev)
384
385
def _update_sha_map_revision(self, revid):
386
rev = self.repository.get_revision(revid)
387
tree = self.tree_cache.revision_tree(rev.revision_id)
388
updater = self._get_updater(rev)
389
for path, obj, ie in self._revision_to_objects(rev, tree,
390
roundtrip=True):
391
updater.add_object(obj, ie)
392
commit_obj = updater.finish()
393
return commit_obj.id
394
395
def _reconstruct_blobs(self, keys):
396
"""Return a Git Blob object from a fileid and revision stored in bzr.
397
398
:param fileid: File id of the text
399
:param revision: Revision of the text
400
"""
401
stream = self.repository.iter_files_bytes(
402
((key[0], key[1], key) for key in keys))
403
for (fileid, revision, expected_sha), chunks in stream:
404
blob = Blob()
405
blob.chunked = chunks
406
if blob.id != expected_sha and blob.data == "":
407
# Perhaps it's a symlink ?
408
tree = self.tree_cache.revision_tree(revision)
409
entry = tree.inventory[fileid]
410
if entry.kind == 'symlink':
411
blob = symlink_to_blob(entry)
412
_check_expected_sha(expected_sha, blob)
413
yield blob
414
415
def _reconstruct_tree(self, fileid, revid, inv, unusual_modes,
416
expected_sha=None):
116
if foreign_revid != commit_obj.id:
117
if not "fix-shamap" in debug.debug_flags:
118
raise AssertionError("recreated git commit had different sha1: expected %s, got %s" % (foreign_revid, commit_obj.id))
119
self._idmap.add_entry(commit_obj.id, "commit", (revid, tree_sha))
120
121
def _check_expected_sha(self, expected_sha, object):
122
if expected_sha is None:
123
return
124
if len(expected_sha) == 40:
125
if expected_sha != object.sha().hexdigest():
126
raise AssertionError("Invalid sha for %r: %s" % (object, expected_sha))
127
elif len(expected_sha) == 20:
128
if expected_sha != object.sha().digest():
129
raise AssertionError("Invalid sha for %r: %s" % (object, sha_to_hex(expected_sha)))
130
else:
131
raise AssertionError("Unknown length %d for %r" % (len(expected_sha), expected_sha))
132
133
def _get_ie_object(self, entry, inv, unusual_modes):
134
if entry.kind == "directory":
135
return self._get_tree(entry.file_id, inv.revision_id, inv, unusual_modes)
136
elif entry.kind == "symlink":
137
return self._get_blob_for_symlink(entry.symlink_target)
138
elif entry.kind == "file":
139
return self._get_blob_for_file(entry.file_id, entry.revision)
140
else:
141
raise AssertionError("unknown entry kind '%s'" % entry.kind)
142
143
def _get_ie_object_or_sha1(self, entry, inv, unusual_modes):
144
if entry.kind == "directory":
145
try:
146
return self._idmap.lookup_tree(entry.file_id, inv.revision_id), None
147
except KeyError:
148
ret = self._get_ie_object(entry, inv, unusual_modes)
149
if ret is None:
150
hexsha = None
151
else:
152
hexsha = ret.id
153
self._idmap.add_entry(hexsha, "tree", (entry.file_id, inv.revision_id))
154
return hexsha, ret
155
elif entry.kind in ("file", "symlink"):
156
try:
157
return self._idmap.lookup_blob(entry.file_id, entry.revision), None
158
except KeyError:
159
ret = self._get_ie_object(entry, inv, unusual_modes)
160
self._idmap.add_entry(ret.id, "blob", (entry.file_id, entry.revision))
161
return ret.id, ret
162
else:
163
raise AssertionError("unknown entry kind '%s'" % entry.kind)
164
165
def _get_ie_sha1(self, entry, inv, unusual_modes):
166
return self._get_ie_object_or_sha1(entry, inv, unusual_modes)[0]
167
168
def _get_blob_for_symlink(self, symlink_target, expected_sha=None):
169
"""Return a Git Blob object for symlink.
170
171
:param symlink_target: target of symlink.
172
"""
173
if type(symlink_target) == unicode:
174
symlink_target = symlink_target.encode('utf-8')
175
blob = Blob()
176
blob._text = symlink_target
177
self._check_expected_sha(expected_sha, blob)
178
return blob
179
180
def _get_blob_for_file(self, fileid, revision, expected_sha=None):
181
"""Return a Git Blob object from a fileid and revision stored in bzr.
182
183
:param fileid: File id of the text
184
:param revision: Revision of the text
185
"""
186
blob = Blob()
187
chunks = self.repository.iter_files_bytes([(fileid, revision, None)]).next()[1]
188
blob._text = "".join(chunks)
189
self._check_expected_sha(expected_sha, blob)
190
return blob
191
192
def _get_blob(self, fileid, revision, expected_sha=None):
193
"""Return a Git Blob object from a fileid and revision stored in bzr.
194
195
:param fileid: File id of the text
196
:param revision: Revision of the text
197
"""
198
inv = self.repository.get_inventory(revision)
199
entry = inv[fileid]
200
201
if entry.kind == 'file':
202
return self._get_blob_for_file(entry.file_id, entry.revision,
203
expected_sha=expected_sha)
204
elif entry.kind == 'symlink':
205
return self._get_blob_for_symlink(entry.symlink_target,
206
expected_sha=expected_sha)
207
else:
208
raise AssertionError
209
210
def _get_tree(self, fileid, revid, inv, unusual_modes, expected_sha=None):
417
211
"""Return a Git Tree object from a file id and a revision stored in bzr.
418
212
419
213
:param fileid: fileid in the tree.
420
214
:param revision: Revision of the tree.
421
215
"""
422
def get_ie_sha1(entry):
423
if entry.kind == "directory":
424
try:
425
return self._cache.idmap.lookup_tree_id(entry.file_id,
426
revid)
427
except (NotImplementedError, KeyError):
428
obj = self._reconstruct_tree(entry.file_id, revid, inv,
429
unusual_modes)
430
if obj is None:
431
return None
432
else:
433
return obj.id
434
elif entry.kind in ("file", "symlink"):
435
try:
436
return self._cache.idmap.lookup_blob_id(entry.file_id,
437
entry.revision)
438
except KeyError:
439
# no-change merge?
440
return self._reconstruct_blobs(
441
[(entry.file_id, entry.revision, None)]).next().id
442
else:
443
raise AssertionError("unknown entry kind '%s'" % entry.kind)
444
tree = directory_to_tree(inv[fileid], get_ie_sha1, unusual_modes,
445
self.mapping.BZR_DUMMY_FILE)
446
_check_expected_sha(expected_sha, tree)
216
tree = directory_to_tree(inv[fileid],
217
lambda ie: self._get_ie_sha1(ie, inv, unusual_modes),
218
unusual_modes)
219
self._check_expected_sha(expected_sha, tree)
447
220
return tree
448
221
222
def _get_commit(self, rev, tree_sha, expected_sha=None):
223
commit = self._revision_to_commit(rev, tree_sha)
224
self._check_expected_sha(expected_sha, commit)
225
return commit
226
449
227
def get_parents(self, sha):
450
228
"""Retrieve the parents of a Git commit by SHA1.
451
229
456
234
457
235
def _lookup_revision_sha1(self, revid):
458
236
"""Return the SHA1 matching a Bazaar revision."""
459
from dulwich.protocol import ZERO_SHA
460
237
if revid == NULL_REVISION:
461
return ZERO_SHA
238
return "0" * 40
462
239
try:
463
return self._cache.idmap.lookup_commit(revid)
240
return self._idmap.lookup_commit(revid)
464
241
except KeyError:
465
242
try:
466
243
return mapping_registry.parse_revision_id(revid)[0]
467
244
except errors.InvalidRevisionId:
468
245
self._update_sha_map(revid)
469
return self._cache.idmap.lookup_commit(revid)
246
return self._idmap.lookup_commit(revid)
470
247
471
248
def get_raw(self, sha):
472
249
"""Get the raw representation of a Git object by SHA1.
479
256
def __contains__(self, sha):
480
257
# See if sha is in map
481
258
try:
482
(type, type_data) = self.lookup_git_sha(sha)
259
(type, type_data) = self._lookup_git_sha(sha)
483
260
if type == "commit":
484
261
return self.repository.has_revision(type_data[0])
485
262
elif type == "blob":
490
267
raise AssertionError("Unknown object type '%s'" % type)
491
268
except KeyError:
492
269
return False
493
494
def lookup_git_shas(self, shas, update_map=True):
495
ret = {}
496
for sha in shas:
497
try:
498
ret[sha] = self._cache.idmap.lookup_git_sha(sha)
499
except KeyError:
500
if update_map:
501
# if not, see if there are any unconverted revisions and add
502
# them to the map, search for sha in map again
503
self._update_sha_map()
504
update_map = False
505
try:
506
ret[sha] = self._cache.idmap.lookup_git_sha(sha)
507
except KeyError:
508
pass
509
return ret
510
511
def lookup_git_sha(self, sha, update_map=True):
512
return self.lookup_git_shas([sha], update_map=update_map)[sha]
270
else:
271
return True
272
273
def _lookup_git_sha(self, sha):
274
# See if sha is in map
275
try:
276
return self._idmap.lookup_git_sha(sha)
277
except KeyError:
278
# if not, see if there are any unconverted revisions and add them
279
# to the map, search for sha in map again
280
self._update_sha_map()
281
return self._idmap.lookup_git_sha(sha)
513
282
514
283
def __getitem__(self, sha):
515
if self._cache.content_cache is not None:
516
try:
517
return self._cache.content_cache[sha]
518
except KeyError:
519
pass
520
(type, type_data) = self.lookup_git_sha(sha)
284
(type, type_data) = self._lookup_git_sha(sha)
521
285
# convert object to git object
522
286
if type == "commit":
523
(revid, tree_sha) = type_data
524
287
try:
525
rev = self.repository.get_revision(revid)
288
rev = self.repository.get_revision(type_data[0])
526
289
except errors.NoSuchRevision:
527
trace.mutter('entry for %s %s in shamap: %r, but not found in '
528
'repository', type, sha, type_data)
290
trace.mutter('entry for %s %s in shamap: %r, but not found in repository', type, sha, type_data)
529
291
raise KeyError(sha)
530
commit = self._reconstruct_commit(rev, tree_sha, roundtrip=True)
531
_check_expected_sha(sha, commit)
532
return commit
292
return self._get_commit(rev, type_data[1], expected_sha=sha)
533
293
elif type == "blob":
534
(fileid, revision) = type_data
535
return self._reconstruct_blobs([(fileid, revision, sha)]).next()
294
return self._get_blob(type_data[0], type_data[1], expected_sha=sha)
536
295
elif type == "tree":
537
(fileid, revid) = type_data
538
296
try:
539
tree = self.tree_cache.revision_tree(revid)
540
rev = self.repository.get_revision(revid)
297
inv = self.repository.get_inventory(type_data[1])
298
rev = self.repository.get_revision(type_data[1])
541
299
except errors.NoSuchRevision:
542
300
trace.mutter('entry for %s %s in shamap: %r, but not found in repository', type, sha, type_data)
543
301
raise KeyError(sha)
544
302
unusual_modes = extract_unusual_modes(rev)
545
303
try:
546
return self._reconstruct_tree(fileid, revid, tree.inventory,
547
unusual_modes, expected_sha=sha)
304
return self._get_tree(type_data[0], type_data[1], inv, unusual_modes,
305
expected_sha=sha)
548
306
except errors.NoSuchRevision:
549
307
raise KeyError(sha)
550
308
else:
551
309
raise AssertionError("Unknown object type '%s'" % type)
552
553
def generate_pack_contents(self, have, want, progress=None,
554
get_tagged=None):
555
"""Iterate over the contents of a pack file.
556
557
:param have: List of SHA1s of objects that should not be sent
558
:param want: List of SHA1s of objects that should be sent
559
"""
560
processed = set()
561
ret = self.lookup_git_shas(have + want)
562
for commit_sha in have:
563
try:
564
(type, (revid, tree_sha)) = ret[commit_sha]
565
except KeyError:
566
pass
567
else:
568
assert type == "commit"
569
processed.add(revid)
570
pending = set()
571
for commit_sha in want:
572
if commit_sha in have:
573
continue
574
try:
575
(type, (revid, tree_sha)) = ret[commit_sha]
576
except KeyError:
577
pass
578
else:
579
assert type == "commit"
580
pending.add(revid)
581
582
todo = _find_missing_bzr_revids(self.repository.get_parent_map,
583
pending, processed)
584
trace.mutter('sending revisions %r', todo)
585
ret = []
586
pb = ui.ui_factory.nested_progress_bar()
587
try:
588
for i, revid in enumerate(todo):
589
pb.update("generating git objects", i, len(todo))
590
rev = self.repository.get_revision(revid)
591
tree = self.tree_cache.revision_tree(revid)
592
for path, obj, ie in self._revision_to_objects(rev, tree):
593
ret.append((obj, path))
594
finally:
595
pb.finished()
596
return ret
597
598
def add_thin_pack(self):
599
import tempfile
600
import os
601
fd, path = tempfile.mkstemp(suffix=".pack")
602
f = os.fdopen(fd, 'wb')
603
def commit():
604
from dulwich.pack import PackData, Pack
605
from bzrlib.plugins.git.fetch import import_git_objects
606
os.fsync(fd)
607
f.close()
608
if os.path.getsize(path) == 0:
609
return
610
pd = PackData(path)
611
pd.create_index_v2(path[:-5]+".idx", self.object_store.get_raw)
612
613
p = Pack(path[:-5])
614
self.repository.lock_write()
615
try:
616
self.repository.start_write_group()
617
try:
618
import_git_objects(self.repository, self.mapping,
619
p.iterobjects(get_raw=self.get_raw),
620
self.object_store)
621
except:
622
self.repository.abort_write_group()
623
raise
624
else:
625
self.repository.commit_write_group()
626
finally:
627
self.repository.unlock()
628
return f, commit
629
630
# The pack isn't kept around anyway, so no point
631
# in treating full packs different from thin packs
632
add_pack = add_thin_pack
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0