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 dulwich/pack.py
- browse files at revision 0.211.20
- compare with another revision
- download diff
- download tarball
- view history from revision 0.211.20
- Committer: Jelmer Vernooij
- Date: 2008-12-11 07:30:52 UTC
- mto: (0.215.1 trunk)
- mto: This revision was merged to the branch mainline in revision 6960.
- Revision ID: jelmer@samba.org-20081211073052-lq0ypg5h3vvyzp3j
Change project name to dulwich everywhere, add assertion.
- files removed:
- dulwich/bin
- dulwich/docs
- foreign
- tests
- files modified:
added
removed
dulwich/pack.py
33
33
a pointer in to the corresponding packfile.
34
34
"""
35
35
36
from collections import defaultdict
37
import hashlib
38
from itertools import imap, izip
39
36
import mmap
40
37
import os
41
import sha
42
import struct
43
38
import sys
44
import zlib
45
46
from objects import (
47
ShaFile,
48
)
49
from errors import ApplyDeltaError
50
39
51
40
supports_mmap_offset = (sys.version_info[0] >= 3 or
52
41
(sys.version_info[0] == 2 and sys.version_info[1] >= 6))
53
42
54
55
def take_msb_bytes(map, offset):
56
ret = []
57
while len(ret) == 0 or ret[-1] & 0x80:
58
ret.append(ord(map[offset]))
59
offset += 1
60
return ret
61
62
63
def read_zlib(data, offset, dec_size):
64
obj = zlib.decompressobj()
65
x = ""
66
fed = 0
67
while obj.unused_data == "":
68
base = offset+fed
69
add = data[base:base+1024]
70
fed += len(add)
71
x += obj.decompress(add)
72
assert len(x) == dec_size
73
comp_len = fed-len(obj.unused_data)
74
return x, comp_len
75
76
77
def iter_sha1(iter):
78
sha = hashlib.sha1()
79
for name in iter:
80
sha.update(name)
81
return sha.hexdigest()
82
83
84
def hex_to_sha(hex):
85
"""Convert a hex string to a binary sha string."""
86
ret = ""
87
for i in range(0, len(hex), 2):
88
ret += chr(int(hex[i:i+2], 16))
89
return ret
90
91
92
def sha_to_hex(sha):
93
"""Convert a binary sha string to a hex sha string."""
94
ret = ""
95
for i in sha:
96
ret += "%02x" % ord(i)
97
return ret
98
43
from objects import (ShaFile,
44
_decompress,
45
)
46
47
hex_to_sha = lambda hex: int(hex, 16)
99
48
100
49
MAX_MMAP_SIZE = 256 * 1024 * 1024
101
50
102
51
def simple_mmap(f, offset, size, access=mmap.ACCESS_READ):
103
"""Simple wrapper for mmap() which always supports the offset parameter.
104
105
:param f: File object.
106
:param offset: Offset in the file, from the beginning of the file.
107
:param size: Size of the mmap'ed area
108
:param access: Access mechanism.
109
:return: MMAP'd area.
110
"""
111
52
if offset+size > MAX_MMAP_SIZE and not supports_mmap_offset:
112
53
raise AssertionError("%s is larger than 256 meg, and this version "
113
54
"of Python does not support the offset argument to mmap().")
126
67
def __getitem__(self, i):
127
68
return self.array[i+self.offset]
128
69
129
def __len__(self):
130
return len(self.array) - self.offset
131
132
def __str__(self):
133
return str(self.array[self.offset:])
134
135
mem = mmap.mmap(f.fileno(), size+offset, access=access)
70
mem = mmap.mmap(f.fileno(), size, access=access)
136
71
if offset == 0:
137
72
return mem
138
73
return ArraySkipper(mem, offset)
139
74
140
75
141
def resolve_object(offset, type, obj, get_ref, get_offset):
142
"""Resolve an object, possibly resolving deltas when necessary."""
143
if not type in (6, 7): # Not a delta
144
return type, obj
145
146
if type == 6: # offset delta
147
(delta_offset, delta) = obj
148
assert isinstance(delta_offset, int)
149
assert isinstance(delta, str)
150
offset = offset-delta_offset
151
type, base_obj = get_offset(offset)
152
assert isinstance(type, int)
153
elif type == 7: # ref delta
154
(basename, delta) = obj
155
assert isinstance(basename, str) and len(basename) == 20
156
assert isinstance(delta, str)
157
type, base_obj = get_ref(basename)
158
assert isinstance(type, int)
159
type, base_text = resolve_object(offset, type, base_obj, get_ref, get_offset)
160
return type, apply_delta(base_text, delta)
161
76
def multi_ord(map, start, count):
77
value = 0
78
for i in range(count):
79
value = value * 0x100 + ord(map[start+i])
80
return value
162
81
163
82
class PackIndex(object):
164
83
"""An index in to a packfile.
174
93
the start and end offset and then bisect in to find if the value is present.
175
94
"""
176
95
96
header_record_size = 4
97
header_size = 256 * header_record_size
98
index_size = 4
99
sha_bytes = 20
100
record_size = sha_bytes + index_size
101
177
102
def __init__(self, filename):
178
103
"""Create a pack index object.
179
104
181
106
it whenever required.
182
107
"""
183
108
self._filename = filename
109
assert os.path.exists(filename), "%s is not a pack index" % filename
184
110
# Take the size now, so it can be checked each time we map the file to
185
111
# ensure that it hasn't changed.
186
112
self._size = os.path.getsize(filename)
187
self._file = open(filename, 'r')
188
self._contents = simple_mmap(self._file, 0, self._size)
189
if self._contents[:4] != '\377tOc':
190
self.version = 1
191
self._fan_out_table = self._read_fan_out_table(0)
192
else:
193
(self.version, ) = struct.unpack_from(">L", self._contents, 4)
194
assert self.version in (2,), "Version was %d" % self.version
195
self._fan_out_table = self._read_fan_out_table(8)
196
self._name_table_offset = 8 + 0x100 * 4
197
self._crc32_table_offset = self._name_table_offset + 20 * len(self)
198
self._pack_offset_table_offset = self._crc32_table_offset + 4 * len(self)
199
200
def __eq__(self, other):
201
if type(self) != type(other):
202
return False
203
204
if self._fan_out_table != other._fan_out_table:
205
return False
206
207
for (name1, _, _), (name2, _, _) in izip(self.iterentries(), other.iterentries()):
208
if name1 != name2:
209
return False
210
return True
211
212
def close(self):
213
self._file.close()
214
215
def __len__(self):
216
"""Return the number of entries in this pack index."""
217
return self._fan_out_table[-1]
218
219
def _unpack_entry(self, i):
220
"""Unpack the i-th entry in the index file.
221
222
:return: Tuple with object name (SHA), offset in pack file and
223
CRC32 checksum (if known)."""
224
if self.version == 1:
225
(offset, name) = struct.unpack_from(">L20s", self._contents,
226
(0x100 * 4) + (i * 24))
227
return (name, offset, None)
228
else:
229
return (self._unpack_name(i), self._unpack_offset(i),
230
self._unpack_crc32_checksum(i))
231
232
def _unpack_name(self, i):
233
if self.version == 1:
234
return self._unpack_entry(i)[0]
235
else:
236
return struct.unpack_from("20s", self._contents,
237
self._name_table_offset + i * 20)[0]
238
239
def _unpack_offset(self, i):
240
if self.version == 1:
241
return self._unpack_entry(i)[1]
242
else:
243
return struct.unpack_from(">L", self._contents,
244
self._pack_offset_table_offset + i * 4)[0]
245
246
def _unpack_crc32_checksum(self, i):
247
if self.version == 1:
248
return None
249
else:
250
return struct.unpack_from(">L", self._contents,
251
self._crc32_table_offset + i * 4)[0]
252
253
def __iter__(self):
254
return imap(sha_to_hex, self._itersha())
255
256
def _itersha(self):
257
for i in range(len(self)):
258
yield self._unpack_name(i)
259
260
def objects_sha1(self):
261
return iter_sha1(self._itersha())
262
263
def iterentries(self):
264
"""Iterate over the entries in this pack index.
265
266
Will yield tuples with object name, offset in packfile and crc32 checksum.
267
"""
268
for i in range(len(self)):
269
yield self._unpack_entry(i)
270
271
def _read_fan_out_table(self, start_offset):
272
ret = []
273
for i in range(0x100):
274
ret.append(struct.unpack(">L", self._contents[start_offset+i*4:start_offset+(i+1)*4])[0])
275
return ret
276
277
def check(self):
278
"""Check that the stored checksum matches the actual checksum."""
279
return self.calculate_checksum() == self.get_stored_checksums()[1]
280
281
def calculate_checksum(self):
282
f = open(self._filename, 'r')
283
try:
284
return hashlib.sha1(self._contents[:-20]).digest()
285
finally:
286
f.close()
287
288
def get_stored_checksums(self):
289
"""Return the SHA1 checksums stored for the corresponding packfile and
290
this header file itself."""
291
return str(self._contents[-40:-20]), str(self._contents[-20:])
113
assert self._size > self.header_size, "%s is too small to be a packfile" % \
114
filename
292
115
293
116
def object_index(self, sha):
294
117
"""Return the index in to the corresponding packfile for the object.
300
123
size = os.path.getsize(self._filename)
301
124
assert size == self._size, "Pack index %s has changed size, I don't " \
302
125
"like that" % self._filename
303
if len(sha) == 40:
304
sha = hex_to_sha(sha)
305
return self._object_index(sha)
126
f = open(self._filename, 'rb')
127
try:
128
map = simple_mmap(f, 0, size)
129
return self._object_index(map, sha)
130
finally:
131
f.close()
306
132
307
def _object_index(self, sha):
308
"""See object_index"""
309
idx = ord(sha[0])
310
if idx == 0:
311
start = 0
133
def _object_index(self, map, hexsha):
134
"""See object_index"""
135
first_byte = hex_to_sha(hexsha[:2])
136
header_offset = self.header_record_size * first_byte
137
start = multi_ord(map, header_offset-self.header_record_size, self.header_record_size)
138
end = multi_ord(map, header_offset, self.header_record_size)
139
sha = hex_to_sha(hexsha)
140
while start < end:
141
i = (start + end)/2
142
offset = self.header_size + (i * self.record_size)
143
file_sha = multi_ord(map, offset + self.index_size, self.sha_bytes)
144
if file_sha == sha:
145
return multi_ord(map, offset, self.index_size)
146
elif file_sha < sha:
147
start = offset + 1
312
148
else:
313
start = self._fan_out_table[idx-1]
314
end = self._fan_out_table[idx]
315
assert start <= end
316
while start <= end:
317
i = (start + end)/2
318
file_sha = self._unpack_name(i)
319
if file_sha < sha:
320
start = i + 1
321
elif file_sha > sha:
322
end = i - 1
323
else:
324
return self._unpack_offset(i)
325
return None
149
end = offset - 1
150
return None
326
151
327
152
328
153
class PackData(object):
364
189
self._filename = filename
365
190
assert os.path.exists(filename), "%s is not a packfile" % filename
366
191
self._size = os.path.getsize(filename)
367
self._header_size = 12
368
assert self._size >= self._header_size, "%s is too small for a packfile" % filename
369
self._read_header()
370
371
def _read_header(self):
372
f = open(self._filename, 'rb')
373
try:
374
header = f.read(12)
375
f.seek(self._size-20)
376
self._stored_checksum = f.read(20)
377
finally:
378
f.close()
379
assert header[:4] == "PACK"
380
(version,) = struct.unpack_from(">L", header, 4)
381
assert version in (2, 3), "Version was %d" % version
382
(self._num_objects,) = struct.unpack_from(">L", header, 8)
383
384
def __len__(self):
385
"""Returns the number of objects in this pack."""
386
return self._num_objects
387
388
def calculate_checksum(self):
389
f = open(self._filename, 'rb')
390
try:
391
map = simple_mmap(f, 0, self._size)
392
return hashlib.sha1(map[:-20]).digest()
393
finally:
394
f.close()
395
396
def iterobjects(self):
397
offset = self._header_size
398
f = open(self._filename, 'rb')
399
for i in range(len(self)):
400
map = simple_mmap(f, offset, self._size-offset)
401
(type, obj, total_size) = self._unpack_object(map)
402
yield offset, type, obj
403
offset += total_size
404
f.close()
405
406
def iterentries(self, ext_resolve_ref=None):
407
found = {}
408
at = {}
409
postponed = defaultdict(list)
410
class Postpone(Exception):
411
"""Raised to postpone delta resolving."""
412
413
def get_ref_text(sha):
414
if sha in found:
415
return found[sha]
416
if ext_resolve_ref:
417
try:
418
return ext_resolve_ref(sha)
419
except KeyError:
420
pass
421
raise Postpone, (sha, )
422
todo = list(self.iterobjects())
423
while todo:
424
(offset, type, obj) = todo.pop(0)
425
at[offset] = (type, obj)
426
assert isinstance(offset, int)
427
assert isinstance(type, int)
428
assert isinstance(obj, tuple) or isinstance(obj, str)
429
try:
430
type, obj = resolve_object(offset, type, obj, get_ref_text,
431
at.__getitem__)
432
except Postpone, (sha, ):
433
postponed[sha].append((offset, type, obj))
434
else:
435
shafile = ShaFile.from_raw_string(type, obj)
436
sha = shafile.sha().digest()
437
found[sha] = (type, obj)
438
yield sha, offset, shafile.crc32()
439
todo += postponed.get(sha, [])
440
if postponed:
441
raise KeyError([sha_to_hex(h) for h in postponed.keys()])
442
443
def sorted_entries(self, resolve_ext_ref=None):
444
ret = list(self.iterentries(resolve_ext_ref))
445
ret.sort()
446
return ret
447
448
def create_index_v1(self, filename):
449
entries = self.sorted_entries()
450
write_pack_index_v1(filename, entries, self.calculate_checksum())
451
452
def create_index_v2(self, filename):
453
entries = self.sorted_entries()
454
write_pack_index_v2(filename, entries, self.calculate_checksum())
455
456
def get_stored_checksum(self):
457
return self._stored_checksum
458
459
def check(self):
460
return (self.calculate_checksum() == self.get_stored_checksum())
461
192
462
193
def get_object_at(self, offset):
463
194
"""Given an offset in to the packfile return the object that is there.
465
196
Using the associated index the location of an object can be looked up, and
466
197
then the packfile can be asked directly for that object using this
467
198
function.
199
200
Currently only non-delta objects are supported.
468
201
"""
469
assert isinstance(offset, long) or isinstance(offset, int),\
470
"offset was %r" % offset
471
assert offset >= self._header_size
202
assert isinstance(offset, long) or isinstance(offset, int)
472
203
size = os.path.getsize(self._filename)
473
204
assert size == self._size, "Pack data %s has changed size, I don't " \
474
205
"like that" % self._filename
475
206
f = open(self._filename, 'rb')
476
207
try:
477
map = simple_mmap(f, offset, size-offset)
478
return self._unpack_object(map)[:2]
208
map = simple_mmap(f, offset, size)
209
return self._get_object_at(map)
479
210
finally:
480
211
f.close()
481
212
482
def _unpack_object(self, map):
483
bytes = take_msb_bytes(map, 0)
484
type = (bytes[0] >> 4) & 0x07
485
size = bytes[0] & 0x0f
486
for i, byte in enumerate(bytes[1:]):
487
size += (byte & 0x7f) << ((i * 7) + 4)
488
raw_base = len(bytes)
489
if type == 6: # offset delta
490
bytes = take_msb_bytes(map, raw_base)
491
assert not (bytes[-1] & 0x80)
492
delta_base_offset = bytes[0] & 0x7f
493
for byte in bytes[1:]:
494
delta_base_offset += 1
495
delta_base_offset <<= 7
496
delta_base_offset += (byte & 0x7f)
497
raw_base+=len(bytes)
498
uncomp, comp_len = read_zlib(map, raw_base, size)
499
assert size == len(uncomp)
500
return type, (delta_base_offset, uncomp), comp_len+raw_base
501
elif type == 7: # ref delta
502
basename = map[raw_base:raw_base+20]
503
uncomp, comp_len = read_zlib(map, raw_base+20, size)
504
assert size == len(uncomp)
505
return type, (basename, uncomp), comp_len+raw_base+20
506
else:
507
uncomp, comp_len = read_zlib(map, raw_base, size)
508
assert len(uncomp) == size
509
return type, uncomp, comp_len+raw_base
510
511
512
class SHA1Writer(object):
513
514
def __init__(self, f):
515
self.f = f
516
self.sha1 = hashlib.sha1("")
517
518
def write(self, data):
519
self.sha1.update(data)
520
self.f.write(data)
521
522
def write_sha(self):
523
sha = self.sha1.digest()
524
assert len(sha) == 20
525
self.f.write(sha)
526
return sha
527
528
def close(self):
529
sha = self.write_sha()
530
self.f.close()
531
return sha
532
533
def tell(self):
534
return self.f.tell()
535
536
537
def write_pack_object(f, type, object):
538
"""Write pack object to a file.
539
540
:param f: File to write to
541
:param o: Object to write
542
"""
543
ret = f.tell()
544
if type == 6: # ref delta
545
(delta_base_offset, object) = object
546
elif type == 7: # offset delta
547
(basename, object) = object
548
size = len(object)
549
c = (type << 4) | (size & 15)
550
size >>= 4
551
while size:
552
f.write(chr(c | 0x80))
553
c = size & 0x7f
554
size >>= 7
555
f.write(chr(c))
556
if type == 6: # offset delta
557
ret = [delta_base_offset & 0x7f]
558
delta_base_offset >>= 7
559
while delta_base_offset:
560
delta_base_offset -= 1
561
ret.insert(0, 0x80 | (delta_base_offset & 0x7f))
562
delta_base_offset >>= 7
563
f.write("".join([chr(x) for x in ret]))
564
elif type == 7: # ref delta
565
assert len(basename) == 20
566
f.write(basename)
567
f.write(zlib.compress(object))
568
return f.tell()
569
570
571
def write_pack(filename, objects, num_objects):
572
f = open(filename + ".pack", 'w')
573
try:
574
entries, data_sum = write_pack_data(f, objects, num_objects)
575
except:
576
f.close()
577
entries.sort()
578
write_pack_index_v2(filename + ".idx", entries, data_sum)
579
580
581
def write_pack_data(f, objects, num_objects):
582
"""Write a new pack file.
583
584
:param filename: The filename of the new pack file.
585
:param objects: List of objects to write.
586
:return: List with (name, offset, crc32 checksum) entries, pack checksum
587
"""
588
entries = []
589
f = SHA1Writer(f)
590
f.write("PACK") # Pack header
591
f.write(struct.pack(">L", 2)) # Pack version
592
f.write(struct.pack(">L", num_objects)) # Number of objects in pack
593
for o in objects:
594
sha1 = o.sha().digest()
595
crc32 = o.crc32()
596
# FIXME: Delta !
597
t, o = o.as_raw_string()
598
offset = write_pack_object(f, t, o)
599
entries.append((sha1, offset, crc32))
600
return entries, f.write_sha()
601
602
603
def write_pack_index_v1(filename, entries, pack_checksum):
604
"""Write a new pack index file.
605
606
:param filename: The filename of the new pack index file.
607
:param entries: List of tuples with object name (sha), offset_in_pack, and
608
crc32_checksum.
609
:param pack_checksum: Checksum of the pack file.
610
"""
611
f = open(filename, 'w')
612
f = SHA1Writer(f)
613
fan_out_table = defaultdict(lambda: 0)
614
for (name, offset, entry_checksum) in entries:
615
fan_out_table[ord(name[0])] += 1
616
# Fan-out table
617
for i in range(0x100):
618
f.write(struct.pack(">L", fan_out_table[i]))
619
fan_out_table[i+1] += fan_out_table[i]
620
for (name, offset, entry_checksum) in entries:
621
f.write(struct.pack(">L20s", offset, name))
622
assert len(pack_checksum) == 20
623
f.write(pack_checksum)
624
f.close()
625
626
627
def apply_delta(src_buf, delta):
628
"""Based on the similar function in git's patch-delta.c."""
629
assert isinstance(src_buf, str), "was %r" % (src_buf,)
630
assert isinstance(delta, str)
631
out = ""
632
def pop(delta):
633
ret = delta[0]
634
delta = delta[1:]
635
return ord(ret), delta
636
def get_delta_header_size(delta):
637
size = 0
638
i = 0
639
while delta:
640
cmd, delta = pop(delta)
641
size |= (cmd & ~0x80) << i
642
i += 7
643
if not cmd & 0x80:
644
break
645
return size, delta
646
src_size, delta = get_delta_header_size(delta)
647
dest_size, delta = get_delta_header_size(delta)
648
assert src_size == len(src_buf)
649
while delta:
650
cmd, delta = pop(delta)
651
if cmd & 0x80:
652
cp_off = 0
653
for i in range(4):
654
if cmd & (1 << i):
655
x, delta = pop(delta)
656
cp_off |= x << (i * 8)
657
cp_size = 0
658
for i in range(3):
659
if cmd & (1 << (4+i)):
660
x, delta = pop(delta)
661
cp_size |= x << (i * 8)
662
if cp_size == 0:
663
cp_size = 0x10000
664
if (cp_off + cp_size < cp_size or
665
cp_off + cp_size > src_size or
666
cp_size > dest_size):
667
break
668
out += src_buf[cp_off:cp_off+cp_size]
669
elif cmd != 0:
670
out += delta[:cmd]
671
delta = delta[cmd:]
672
else:
673
raise ApplyDeltaError("Invalid opcode 0")
674
675
if delta != "":
676
raise ApplyDeltaError("delta not empty: %r" % delta)
677
678
if dest_size != len(out):
679
raise ApplyDeltaError("dest size incorrect")
680
681
return out
682
683
684
def write_pack_index_v2(filename, entries, pack_checksum):
685
"""Write a new pack index file.
686
687
:param filename: The filename of the new pack index file.
688
:param entries: List of tuples with object name (sha), offset_in_pack, and
689
crc32_checksum.
690
:param pack_checksum: Checksum of the pack file.
691
"""
692
f = open(filename, 'w')
693
f = SHA1Writer(f)
694
f.write('\377tOc') # Magic!
695
f.write(struct.pack(">L", 2))
696
fan_out_table = defaultdict(lambda: 0)
697
for (name, offset, entry_checksum) in entries:
698
fan_out_table[ord(name[0])] += 1
699
# Fan-out table
700
for i in range(0x100):
701
f.write(struct.pack(">L", fan_out_table[i]))
702
fan_out_table[i+1] += fan_out_table[i]
703
for (name, offset, entry_checksum) in entries:
704
f.write(name)
705
for (name, offset, entry_checksum) in entries:
706
f.write(struct.pack(">l", entry_checksum))
707
for (name, offset, entry_checksum) in entries:
708
# FIXME: handle if MSBit is set in offset
709
f.write(struct.pack(">L", offset))
710
# FIXME: handle table for pack files > 8 Gb
711
assert len(pack_checksum) == 20
712
f.write(pack_checksum)
713
f.close()
714
715
716
class Pack(object):
717
718
def __init__(self, basename):
719
self._basename = basename
720
self._data_path = self._basename + ".pack"
721
self._idx_path = self._basename + ".idx"
722
self._data = None
723
self._idx = None
724
725
def name(self):
726
return self.idx.objects_sha1()
727
728
@property
729
def data(self):
730
if self._data is None:
731
self._data = PackData(self._data_path)
732
assert len(self.idx) == len(self._data)
733
assert self.idx.get_stored_checksums()[0] == self._data.get_stored_checksum()
734
return self._data
735
736
@property
737
def idx(self):
738
if self._idx is None:
739
self._idx = PackIndex(self._idx_path)
740
return self._idx
741
742
def close(self):
743
if self._data is not None:
744
self._data.close()
745
self.idx.close()
746
747
def __eq__(self, other):
748
return type(self) == type(other) and self.idx == other.idx
749
750
def __len__(self):
751
"""Number of entries in this pack."""
752
return len(self.idx)
753
754
def __repr__(self):
755
return "Pack(%r)" % self._basename
756
757
def __iter__(self):
758
"""Iterate over all the sha1s of the objects in this pack."""
759
return iter(self.idx)
760
761
def check(self):
762
return self.idx.check() and self.data.check()
763
764
def get_stored_checksum(self):
765
return self.data.get_stored_checksum()
766
767
def __contains__(self, sha1):
768
"""Check whether this pack contains a particular SHA1."""
769
return (self.idx.object_index(sha1) is not None)
770
771
def get_raw(self, sha1, resolve_ref=None):
772
if resolve_ref is None:
773
resolve_ref = self.get_raw
774
offset = self.idx.object_index(sha1)
775
if offset is None:
776
raise KeyError(sha1)
777
778
type, obj = self.data.get_object_at(offset)
779
assert isinstance(offset, int)
780
return resolve_object(offset, type, obj, resolve_ref,
781
self.data.get_object_at)
782
783
def __getitem__(self, sha1):
784
"""Retrieve the specified SHA1."""
785
type, uncomp = self.get_raw(sha1)
786
return ShaFile.from_raw_string(type, uncomp)
787
788
def iterobjects(self):
789
for offset, type, obj in self.data.iterobjects():
790
assert isinstance(offset, int)
791
yield ShaFile.from_raw_string(
792
*resolve_object(offset, type, obj, self.get_raw,
793
self.data.get_object_at))
794
795
796
def load_packs(path):
797
if not os.path.exists(path):
798
return
799
for name in os.listdir(path):
800
if name.startswith("pack-") and name.endswith(".pack"):
801
yield Pack(os.path.join(path, name[:-len(".pack")]))
213
def _get_object_at(self, map):
214
first_byte = ord(map[0])
215
sign_extend = first_byte & 0x80
216
type = (first_byte >> 4) & 0x07
217
size = first_byte & 0x0f
218
cur_offset = 0
219
while sign_extend > 0:
220
byte = ord(map[cur_offset+1])
221
sign_extend = byte & 0x80
222
size_part = byte & 0x7f
223
size += size_part << ((cur_offset * 7) + 4)
224
cur_offset += 1
225
raw_base = cur_offset+1
226
# The size is the inflated size, so we have no idea what the deflated size
227
# is, so for now give it as much as we have. It should really iterate
228
# feeding it more data if it doesn't decompress, but as we have the whole
229
# thing then just use it.
230
raw = map[raw_base:]
231
uncomp = _decompress(raw)
232
obj = ShaFile.from_raw_string(type, uncomp)
233
return obj
234
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0