2 from __future__ import absolute_import
5 from bup import _helpers, compat, helpers
6 from bup._helpers import cat_bytes
7 from bup.compat import buffer, py_maj
8 from bup.helpers import sc_page_size
11 _fmincore = getattr(helpers, 'fmincore', None)
13 BLOB_MAX = 8192*4 # 8192 is the "typical" blob size for bupsplit
14 BLOB_READ_SIZE = 1024*1024
16 progress_callback = None
19 GIT_MODE_FILE = 0o100644
20 GIT_MODE_TREE = 0o40000
21 GIT_MODE_SYMLINK = 0o120000
23 # The purpose of this type of buffer is to avoid copying on peek(), get(),
24 # and eat(). We do copy the buffer contents on put(), but that should
25 # be ok if we always only put() large amounts of data at a time.
36 remaining = len(self.data) - self.start
37 self.data = cat_bytes(self.data, self.start, remaining,
41 def peek(self, count):
43 return self.data[self.start : self.start + count]
44 return buffer(self.data, self.start, count)
51 v = self.data[self.start : self.start + count]
53 v = buffer(self.data, self.start, count)
58 return len(self.data) - self.start
61 def _fadvise_pages_done(fd, first_page, count):
62 assert(first_page >= 0)
65 _helpers.fadvise_done(fd,
66 first_page * sc_page_size,
70 def _nonresident_page_regions(status_bytes, incore_mask, max_region_len=None):
71 """Return (start_page, count) pairs in ascending start_page order for
72 each contiguous region of nonresident pages indicated by the
73 mincore() status_bytes. Limit the number of pages in each region
75 assert(max_region_len is None or max_region_len > 0)
77 for i, x in enumerate(status_bytes):
78 in_core = x & incore_mask
87 elif max_region_len and count >= max_region_len:
91 yield (start, len(status_bytes) - start)
94 def _uncache_ours_upto(fd, offset, first_region, remaining_regions):
95 """Uncache the pages of fd indicated by first_region and
96 remaining_regions that are before offset, where each region is a
97 (start_page, count) pair. The final region must have a start_page
99 rstart, rlen = first_region
100 while rstart is not None and (rstart + rlen) * sc_page_size <= offset:
101 _fadvise_pages_done(fd, rstart, rlen)
102 rstart, rlen = next(remaining_regions, (None, None))
103 return (rstart, rlen)
106 def readfile_iter(files, progress=None):
107 for filenum,f in enumerate(files):
110 fd = rpr = rstart = rlen = None
111 if _fmincore and hasattr(f, 'fileno'):
114 except io.UnsupportedOperation:
117 mcore = _fmincore(fd)
119 max_chunk = max(1, (8 * 1024 * 1024) / sc_page_size)
120 rpr = _nonresident_page_regions(mcore, helpers.MINCORE_INCORE,
122 rstart, rlen = next(rpr, (None, None))
125 progress(filenum, len(b))
126 b = f.read(BLOB_READ_SIZE)
129 rstart, rlen = _uncache_ours_upto(fd, ofs, (rstart, rlen), rpr)
134 rstart, rlen = _uncache_ours_upto(fd, ofs, (rstart, rlen), rpr)
137 def _splitbuf(buf, basebits, fanbits):
139 b = buf.peek(buf.used())
140 (ofs, bits) = _helpers.splitbuf(b)
146 level = (bits-basebits)//fanbits # integer division
148 yield buffer(b, 0, ofs), level
151 while buf.used() >= BLOB_MAX:
152 # limit max blob size
153 yield buf.get(BLOB_MAX), 0
156 def _hashsplit_iter(files, progress):
157 assert(BLOB_READ_SIZE > BLOB_MAX)
158 basebits = _helpers.blobbits()
159 fanbits = int(math.log(fanout or 128, 2))
161 for inblock in readfile_iter(files, progress):
163 for buf_and_level in _splitbuf(buf, basebits, fanbits):
166 yield buf.get(buf.used()), 0
169 def _hashsplit_iter_keep_boundaries(files, progress):
170 for real_filenum,f in enumerate(files):
172 def prog(filenum, nbytes):
173 # the inner _hashsplit_iter doesn't know the real file count,
174 # so we'll replace it here.
175 return progress(real_filenum, nbytes)
178 for buf_and_level in _hashsplit_iter([f], progress=prog):
182 def hashsplit_iter(files, keep_boundaries, progress):
184 return _hashsplit_iter_keep_boundaries(files, progress)
186 return _hashsplit_iter(files, progress)
190 def split_to_blobs(makeblob, files, keep_boundaries, progress):
192 for (blob, level) in hashsplit_iter(files, keep_boundaries, progress):
194 total_split += len(blob)
195 if progress_callback:
196 progress_callback(len(blob))
197 yield (sha, len(blob), level)
200 def _make_shalist(l):
203 total = sum(size for mode,sha,size, in l)
204 vlen = len(b'%x' % total)
206 for (mode, sha, size) in l:
207 shalist.append((mode, b'%0*x' % (vlen,ofs), sha))
210 return (shalist, total)
213 def _squish(maketree, stacks, n):
215 while i < n or len(stacks[i]) >= MAX_PER_TREE:
216 while len(stacks) <= i+1:
218 if len(stacks[i]) == 1:
219 stacks[i+1] += stacks[i]
221 (shalist, size) = _make_shalist(stacks[i])
222 tree = maketree(shalist)
223 stacks[i+1].append((GIT_MODE_TREE, tree, size))
228 def split_to_shalist(makeblob, maketree, files,
229 keep_boundaries, progress=None):
230 sl = split_to_blobs(makeblob, files, keep_boundaries, progress)
234 for (sha,size,level) in sl:
235 shal.append((GIT_MODE_FILE, sha, size))
236 return _make_shalist(shal)[0]
239 for (sha,size,level) in sl:
240 stacks[0].append((GIT_MODE_FILE, sha, size))
241 _squish(maketree, stacks, level)
242 #log('stacks: %r\n' % [len(i) for i in stacks])
243 _squish(maketree, stacks, len(stacks)-1)
244 #log('stacks: %r\n' % [len(i) for i in stacks])
245 return _make_shalist(stacks[-1])[0]
248 def split_to_blob_or_tree(makeblob, maketree, files,
249 keep_boundaries, progress=None):
250 shalist = list(split_to_shalist(makeblob, maketree,
251 files, keep_boundaries, progress))
252 if len(shalist) == 1:
253 return (shalist[0][0], shalist[0][2])
254 elif len(shalist) == 0:
255 return (GIT_MODE_FILE, makeblob(b''))
257 return (GIT_MODE_TREE, maketree(shalist))
260 def open_noatime(name):
261 fd = _helpers.open_noatime(name)
263 return os.fdopen(fd, 'rb', 1024*1024)