Jan Lindemann
66b968c51c
TarIoTarFile is currently unused but should still be correct, so fix a typo in _extract().
Signed-off-by: Jan Lindemann <jan@janware.com>
109 lines
3.8 KiB
Python
109 lines
3.8 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Self
|
|
|
|
import abc, io
|
|
import tarfile
|
|
from tarfile import TarFile
|
|
|
|
from .CopyContext import CopyContext
|
|
from .FileContext import FileContext
|
|
from .log import *
|
|
|
|
class TarIo(CopyContext):
|
|
|
|
def __init__(self, *args, **kwargs) -> None:
|
|
super().__init__(*args, **kwargs, chroot=False)
|
|
|
|
def _match(self, path: str, path_filter: list[str]) -> bool:
|
|
return path in path_filter
|
|
|
|
def _filter_tar_file(self, blob: bytes, path_filter: list[str]|None=None, matched: list[str]|None=None) -> bytes:
|
|
ret = io.BytesIO()
|
|
with tarfile.open(fileobj=ret, mode='w') as tf_out:
|
|
tf_in = TarFile(fileobj=io.BytesIO(blob))
|
|
for info in tf_in.getmembers():
|
|
if path_filter is not None and not self._match(info.name, path_filter):
|
|
continue
|
|
log(DEBUG, f'Adding {info.name}')
|
|
if matched is not None:
|
|
matched.append(info.name)
|
|
buf = tf_in.extractfile(info)
|
|
tf_out.addfile(info, buf)
|
|
return ret.getvalue()
|
|
|
|
async def _read_filtered(self, path, path_filter: list[str]|None=None, matched: list[str]|None=None) -> bytes:
|
|
try:
|
|
blob = (await self.src.get(path)).stdout
|
|
except Exception as e:
|
|
log(ERR, f'Failed to read tar file "{path}" ({str(e)}')
|
|
raise
|
|
return self._filter_tar_file(blob, path_filter, matched=matched)
|
|
|
|
def _add(self, tf: TarFile, path: str, st: StatResult, contents: bytes) -> None:
|
|
file_obj = io.BytesIO(contents)
|
|
info = TarInfo()
|
|
info.name = path
|
|
info.mode = st.mode
|
|
info.uname = st.owner
|
|
info.gname = st.group
|
|
info.size = st.size
|
|
info.atime = st.atime
|
|
info.mtime = st.mtime
|
|
info.ctime = st.ctime
|
|
tf.addfile(info, io.BytesIO(file_obj))
|
|
|
|
async def _add_from_path(self, src: FileContext, tf: TarFile, path: str) -> None:
|
|
contents = await src.get(path)
|
|
st = await self.stat(path)
|
|
self._add(tf, path, st, contents)
|
|
|
|
@abc.abstractmethod
|
|
async def _extract(self, blob: bytes, root: str|None=None) -> None:
|
|
raise NotImplementedError()
|
|
|
|
async def extract(self, root: str|None=None, path_filter: list[str]|None=None) -> list[str]:
|
|
ret: list[str] = []
|
|
filtered = await self._read_filtered(self.src.root, path_filter, matched=ret)
|
|
await self._extract(blob=filtered, root=root)
|
|
return ret
|
|
|
|
@classmethod
|
|
def create(cls, *args, type: str=None, **kwargs):
|
|
if type is not None:
|
|
raise NotImplementedError
|
|
#return TarIoTarFile(*args, **kwargs)
|
|
return TarIoTarExec(*args, **kwargs)
|
|
|
|
class TarIoTarFile(TarIo):
|
|
|
|
async def _extract(self, blob: bytes, root: str|None=None) -> None:
|
|
tf = TarFile(fileobj=io.BytesIO(blob))
|
|
for info in tf.getmembers():
|
|
log(DEBUG, f'Extracting {info.name}')
|
|
path = root + '/' + info.name if root else info.name
|
|
buf = tf.extractfile(info)
|
|
if buf is None:
|
|
if info.isdir():
|
|
await self.dst.mkdir(path, info.mode)
|
|
await self.dst.chown(path, info.uname, info.gname)
|
|
continue
|
|
raise Exception(f'Can\'t extract unsupported file type of "{path}"')
|
|
await self.dst.put(
|
|
path,
|
|
buf.read(),
|
|
owner = info.uname,
|
|
group = info.gname,
|
|
mode = info.mode,
|
|
)
|
|
|
|
class TarIoTarExec(TarIo):
|
|
|
|
async def _extract(self, blob: bytes, root: str|None=None) -> None:
|
|
cmd = ['tar']
|
|
if root is not None:
|
|
cmd += ['-C', root]
|
|
cmd += ['-x', '-f', '-']
|
|
await self.dst.run(cmd, cmd_input=blob)
|