mirror of
https://github.com/qgis/QGIS.git
synced 2025-04-13 00:03:09 -04:00
115 lines
4.0 KiB
Python
115 lines
4.0 KiB
Python
# archive.py -- Creating an archive from a tarball
|
|
# Copyright (C) 2015 Jonas Haag <jonas@lophus.org>
|
|
# Copyright (C) 2015 Jelmer Vernooij <jelmer@jelmer.uk>
|
|
#
|
|
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
|
|
# General Public License as public by the Free Software Foundation; version 2.0
|
|
# or (at your option) any later version. You can redistribute it and/or
|
|
# modify it under the terms of either of these two licenses.
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
# You should have received a copy of the licenses; if not, see
|
|
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
|
|
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
|
|
# License, Version 2.0.
|
|
#
|
|
|
|
"""Generates tarballs for Git trees.
|
|
|
|
"""
|
|
|
|
import posixpath
|
|
import stat
|
|
import tarfile
|
|
from io import BytesIO
|
|
from contextlib import closing
|
|
|
|
|
|
class ChunkedBytesIO(object):
|
|
"""Turn a list of bytestrings into a file-like object.
|
|
|
|
This is similar to creating a `BytesIO` from a concatenation of the
|
|
bytestring list, but saves memory by NOT creating one giant bytestring first::
|
|
|
|
BytesIO(b''.join(list_of_bytestrings)) =~= ChunkedBytesIO(list_of_bytestrings)
|
|
"""
|
|
def __init__(self, contents):
|
|
self.contents = contents
|
|
self.pos = (0, 0)
|
|
|
|
def read(self, maxbytes=None):
|
|
if maxbytes < 0:
|
|
maxbytes = float('inf')
|
|
|
|
buf = []
|
|
chunk, cursor = self.pos
|
|
|
|
while chunk < len(self.contents):
|
|
if maxbytes < len(self.contents[chunk]) - cursor:
|
|
buf.append(self.contents[chunk][cursor:cursor+maxbytes])
|
|
cursor += maxbytes
|
|
self.pos = (chunk, cursor)
|
|
break
|
|
else:
|
|
buf.append(self.contents[chunk][cursor:])
|
|
maxbytes -= len(self.contents[chunk]) - cursor
|
|
chunk += 1
|
|
cursor = 0
|
|
self.pos = (chunk, cursor)
|
|
return b''.join(buf)
|
|
|
|
|
|
def tar_stream(store, tree, mtime, format=''):
|
|
"""Generate a tar stream for the contents of a Git tree.
|
|
|
|
Returns a generator that lazily assembles a .tar.gz archive, yielding it in
|
|
pieces (bytestrings). To obtain the complete .tar.gz binary file, simply
|
|
concatenate these chunks.
|
|
|
|
:param store: Object store to retrieve objects from
|
|
:param tree: Tree object for the tree root
|
|
:param mtime: UNIX timestamp that is assigned as the modification time for
|
|
all files
|
|
:param format: Optional compression format for tarball
|
|
:return: Bytestrings
|
|
"""
|
|
buf = BytesIO()
|
|
with closing(tarfile.open(None, "w:%s" % format, buf)) as tar:
|
|
for entry_abspath, entry in _walk_tree(store, tree):
|
|
try:
|
|
blob = store[entry.sha]
|
|
except KeyError:
|
|
# Entry probably refers to a submodule, which we don't yet support.
|
|
continue
|
|
data = ChunkedBytesIO(blob.chunked)
|
|
|
|
info = tarfile.TarInfo()
|
|
info.name = entry_abspath.decode('ascii') # tarfile only works with ascii.
|
|
info.size = blob.raw_length()
|
|
info.mode = entry.mode
|
|
info.mtime = mtime
|
|
|
|
tar.addfile(info, data)
|
|
yield buf.getvalue()
|
|
buf.truncate(0)
|
|
buf.seek(0)
|
|
yield buf.getvalue()
|
|
|
|
|
|
def _walk_tree(store, tree, root=b''):
|
|
"""Recursively walk a dulwich Tree, yielding tuples of
|
|
(absolute path, TreeEntry) along the way.
|
|
"""
|
|
for entry in tree.iteritems():
|
|
entry_abspath = posixpath.join(root, entry.path)
|
|
if stat.S_ISDIR(entry.mode):
|
|
for _ in _walk_tree(store, store[entry.sha], entry_abspath):
|
|
yield _
|
|
else:
|
|
yield (entry_abspath, entry)
|