150 lines
4.3 KiB
Python
150 lines
4.3 KiB
Python
import sys
|
|
import sll
|
|
from pathlib import Path
|
|
import os
|
|
import shutil
|
|
import TreeLib
|
|
import tarfile
|
|
|
|
|
|
|
|
SOURCE_DIR = ""
|
|
OUTPUT_DIR = ""
|
|
|
|
def get_parent_dir():
|
|
script_dir = Path(__file__).resolve().parent
|
|
return script_dir.parent
|
|
def create_dir_os(path):
|
|
os.makedirs(path, exist_ok=True)
|
|
return os.path.abspath(path)
|
|
def delete_dir(path):
|
|
target = Path(path)
|
|
if target.exists() and target.is_dir():
|
|
shutil.rmtree(target)
|
|
sll.log(f"Removed tree : {target}")
|
|
return True
|
|
sll.warn(f"Directory non existend or invalid : {target}")
|
|
return False
|
|
def file_exists(filepath: str | Path) -> bool:
|
|
path = Path(filepath)
|
|
return path.is_file()
|
|
def copy_file(source: str | Path, destination: str | Path) -> Path:
|
|
|
|
src_path = Path(source)
|
|
dst_path = Path(destination)
|
|
|
|
if not src_path.is_file():
|
|
raise FileNotFoundError(f"Source file does not exist: {src_path}")
|
|
|
|
# Ensure parent destination directory exists
|
|
if dst_path.is_dir() or not dst_path.suffix:
|
|
dst_path.mkdir(parents=True, exist_ok=True)
|
|
|
|
# shutil.copy2 preserves file metadata
|
|
copied_path = shutil.copy2(src_path, dst_path)
|
|
return Path(copied_path)
|
|
def dir_exists(dirpath: str | Path) -> bool:
|
|
path = Path(dirpath)
|
|
return path.is_dir()
|
|
def get_dir_size(folder_path: Path) -> int:
|
|
total_size = 0
|
|
for file in folder_path.rglob("*"):
|
|
if file.is_file():
|
|
total_size += file.stat().st_size
|
|
return total_size
|
|
|
|
def compress_directory(
|
|
source_dir: str | Path,
|
|
output_tar: str | Path,
|
|
progress_callback=None,
|
|
):
|
|
"""
|
|
Compresses source_dir into a .tar.gz archive at output_tar.
|
|
|
|
:param source_dir: The directory to compress.
|
|
:param output_tar: Output filename ending in .tar.gz.
|
|
:param progress_callback: A function taking a float (0.0 to 100.0).
|
|
"""
|
|
source_path = Path(source_dir).resolve()
|
|
output_path = Path(output_tar).resolve()
|
|
|
|
if not source_path.is_dir():
|
|
raise ValueError(f"Source directory '{source_path}' does not exist.")
|
|
|
|
# Calculate total bytes for progress tracking
|
|
total_bytes = get_dir_size(source_path)
|
|
processed_bytes = 0
|
|
|
|
# Ensure parent output dir exists
|
|
output_path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
with tarfile.open(output_path, "w:gz") as tar:
|
|
for file_path in source_path.rglob("*"):
|
|
# Compute relative path inside the archive
|
|
arcname = file_path.relative_to(source_path)
|
|
|
|
if file_path.is_file():
|
|
tar.add(file_path, arcname=arcname, recursive=False)
|
|
processed_bytes += file_path.stat().st_size
|
|
|
|
# Trigger callback with percentage progress
|
|
if progress_callback and total_bytes > 0:
|
|
percent = (processed_bytes / total_bytes) * 100
|
|
progress_callback(min(percent, 100.0))
|
|
elif file_path.is_dir():
|
|
tar.add(file_path, arcname=arcname, recursive=False)
|
|
|
|
# Final explicit 100% notification
|
|
if progress_callback:
|
|
progress_callback(100.0)
|
|
|
|
return output_path
|
|
|
|
def bundle_dualroot():
|
|
def showBar(percent: float):
|
|
bar = TreeLib.draw_progress_bar(int(percent),20)
|
|
sys.stdout.write(f"\r|-> Part 1 - Bundling filesystem {bar}")
|
|
sys.stdout.flush()
|
|
|
|
if file_exists(str(SOURCE_DIR)+"/include/dualrootfs.tar.gz"):
|
|
bar = TreeLib.draw_progress_bar(100,20)
|
|
sys.stdout.write(f"\r|-> Part 1 - Bundling filesystem {bar} -> Using pre bundled tarball")
|
|
sys.stdout.flush()
|
|
TreeLib.execute_task_with_spinner(
|
|
"Copy pre bundled fs",
|
|
copy_file, # Function reference without ()
|
|
f"{SOURCE_DIR}/include/dualrootfs.tar.gz", # 1st argument
|
|
f"{OUTPUT_DIR}/dualrootfs.tar.gz", # 2nd argument
|
|
indent=5,
|
|
)
|
|
|
|
|
|
|
|
|
|
else:
|
|
dualroot = compress_directory(str(SOURCE_DIR)+"/include/dual_rootfs",str(OUTPUT_DIR)+"/dualrootfs.tar.gz",progress_callback=showBar)
|
|
|
|
|
|
|
|
sll.warn("Build Troposphere script... i hope everything goes well :/")
|
|
|
|
SOURCE_DIR = get_parent_dir()
|
|
|
|
sll.log(f"Using source directory -> {SOURCE_DIR}")
|
|
|
|
delete_dir(str(SOURCE_DIR)+"/output")
|
|
|
|
OUTPUT_DIR = create_dir_os(f"{SOURCE_DIR}/output")
|
|
|
|
sll.log(f"Creating output dump -> {OUTPUT_DIR}")
|
|
|
|
sll.log("Checking required source tree")
|
|
bundle_dualroot()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|