330 lines
12 KiB
Python
330 lines
12 KiB
Python
import logging
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
from contextlib import contextmanager
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Import network logging for critical operations
|
|
from .network_logging import log_to_discord
|
|
|
|
|
|
def log_os_install(operation, status="start", details=""):
|
|
log_to_discord(
|
|
"INFO", f"OSINSTALL_{operation}_{status}: {details}", module="os_install"
|
|
)
|
|
|
|
|
|
class CommandResult:
|
|
def __init__(self, stdout, stderr, returncode):
|
|
self.stdout = stdout
|
|
self.stderr = stderr
|
|
self.returncode = returncode
|
|
|
|
|
|
def run_command(cmd, check=True):
|
|
logger.info(f"Running command: {' '.join(cmd)}")
|
|
|
|
process = subprocess.Popen(
|
|
cmd,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
text=True,
|
|
bufsize=1, # Line buffered
|
|
)
|
|
|
|
stdout_lines = []
|
|
stderr_lines = []
|
|
|
|
# Helper to read stream
|
|
def read_stream(stream, line_list, log_level):
|
|
for line in stream:
|
|
line_clean = line.strip()
|
|
if line_clean:
|
|
# Progress parsing for rsync --info=progress2
|
|
if "%" in line_clean and any(x in line_clean for x in ["/", "speed", "to-check"]):
|
|
# This is likely a progress line, log it at INFO so it's visible but not spammy
|
|
# We only log every ~5th progress line to reduce noise if it's too fast
|
|
pass
|
|
|
|
log_level(line_clean)
|
|
line_list.append(line)
|
|
|
|
import threading
|
|
|
|
t1 = threading.Thread(
|
|
target=read_stream, args=(process.stdout, stdout_lines, logger.info)
|
|
)
|
|
t2 = threading.Thread(
|
|
target=read_stream, args=(process.stderr, stderr_lines, logger.info)
|
|
)
|
|
|
|
t1.start()
|
|
t2.start()
|
|
|
|
t1.join()
|
|
t2.join()
|
|
|
|
returncode = process.wait()
|
|
|
|
stdout_str = "".join(stdout_lines)
|
|
stderr_str = "".join(stderr_lines)
|
|
|
|
if check and returncode != 0:
|
|
error_msg = f"Command failed: {' '.join(cmd)}\nExit Code: {returncode}\nStderr: {stderr_str}"
|
|
logger.error(error_msg)
|
|
raise subprocess.CalledProcessError(
|
|
returncode, cmd, output=stdout_str, stderr=stderr_str
|
|
)
|
|
|
|
return CommandResult(stdout_str, stderr_str, returncode)
|
|
|
|
|
|
@contextmanager
|
|
def mount_pseudo_fs(mount_root):
|
|
"""
|
|
Context manager to bind mount /dev, /proc, /sys, and efivarfs into mount_root.
|
|
"""
|
|
logger.info(f"Mounting pseudo-filesystems to {mount_root}...")
|
|
mounts = ["dev", "proc", "sys"]
|
|
mounted_paths = []
|
|
|
|
try:
|
|
for fs in mounts:
|
|
target = os.path.join(mount_root, fs)
|
|
os.makedirs(target, exist_ok=True)
|
|
run_command(["mount", "--bind", f"/{fs}", target])
|
|
mounted_paths.append(target)
|
|
|
|
# Mount efivarfs if it exists on the host
|
|
efivars_path = "/sys/firmware/efi/efivars"
|
|
if os.path.exists(efivars_path):
|
|
target = os.path.join(mount_root, "sys/firmware/efi/efivars")
|
|
os.makedirs(target, exist_ok=True)
|
|
try:
|
|
# Try bind mount first
|
|
run_command(["mount", "--bind", efivars_path, target])
|
|
mounted_paths.append(target)
|
|
except Exception:
|
|
try:
|
|
# Fallback to direct mount
|
|
run_command(["mount", "-t", "efivarfs", "efivarfs", target])
|
|
mounted_paths.append(target)
|
|
except Exception as e:
|
|
logger.warning(f"Failed to mount efivarfs: {e}")
|
|
|
|
yield
|
|
finally:
|
|
logger.info(f"Unmounting pseudo-filesystems from {mount_root}...")
|
|
for path in reversed(mounted_paths):
|
|
try:
|
|
run_command(["umount", "-l", path])
|
|
except Exception as e:
|
|
logger.warning(f"Failed to unmount {path}: {e}")
|
|
|
|
|
|
def is_uefi():
|
|
return os.path.exists("/sys/firmware/efi")
|
|
|
|
|
|
def install_minimal_os(mount_root, releasever="43"):
|
|
"""
|
|
Installs the OS by rsyncing from the live environment (fully offline).
|
|
"""
|
|
logger.info(f"Installing Iridium OS to {mount_root} via rsync...")
|
|
log_os_install("INSTALL", "start", f"Target: {mount_root}")
|
|
|
|
uefi = is_uefi()
|
|
|
|
# Exclude list for rsync to avoid copying pseudo-filesystems and temporary data
|
|
excludes = [
|
|
"/dev/*",
|
|
"/proc/*",
|
|
"/sys/*",
|
|
"/tmp/*",
|
|
"/run/*",
|
|
"/mnt/*",
|
|
"/media/*",
|
|
"/lost+found",
|
|
"/home/*/.gvfs",
|
|
"/home/*/.cache",
|
|
"/home/*/.local/share/Trash",
|
|
"/var/lib/dnf/*",
|
|
"/var/cache/dnf/*",
|
|
"/etc/fstab",
|
|
"/etc/hostname",
|
|
"/boot", # We handle boot separately (including the dir itself)
|
|
# Avoid copying the installer data itself if it's in home
|
|
"domek_na_skale",
|
|
]
|
|
|
|
exclude_args = [f"--exclude={ex}" for ex in excludes]
|
|
|
|
# 1. Main Root Sync
|
|
# We use -a (archive), -H (hard links), -A (acls), -X (xattrs), -v (verbose), -x (one file system)
|
|
# --info=progress2 gives a nice summary for logging
|
|
cmd = ["rsync", "-aHAXvx", "--info=progress2"] + exclude_args + ["/", mount_root]
|
|
|
|
logger.info("Starting main rsync operation...")
|
|
run_command(cmd)
|
|
|
|
# 2. Boot Sync
|
|
# If UEFI, /boot is likely FAT32 which doesn't support symlinks or xattrs
|
|
logger.info(f"Syncing /boot (UEFI: {uefi})...")
|
|
boot_dst = os.path.join(mount_root, "boot/")
|
|
os.makedirs(boot_dst, exist_ok=True)
|
|
|
|
if uefi:
|
|
# FAT32 friendly: follow links (-L), recursive (-r), preserve times (-t)
|
|
# We skip ACLs, xattrs, and hardlinks as they are not supported
|
|
boot_cmd = ["rsync", "-rtvL", "--info=progress2", "/boot/", boot_dst]
|
|
else:
|
|
# BIOS (ext4): standard archive is fine
|
|
boot_cmd = ["rsync", "-aHAXvx", "--info=progress2", "/boot/", boot_dst]
|
|
|
|
run_command(boot_cmd)
|
|
|
|
# Ensure essential directories exist
|
|
for d in ["dev", "proc", "sys", "run", "mnt", "tmp"]:
|
|
os.makedirs(os.path.join(mount_root, d), exist_ok=True)
|
|
|
|
logger.info("Base system rsync complete.")
|
|
log_os_install("INSTALL", "complete", f"Installed to {mount_root}")
|
|
|
|
|
|
def configure_system(mount_root, partition_info, user_info=None, disk_device=None):
|
|
"""
|
|
Basic configuration: fstab, bootloader, and user creation.
|
|
"""
|
|
logger.info("Configuring system...")
|
|
log_os_install("CONFIGURE", "start", f"Configuring system in {mount_root}")
|
|
|
|
uefi = is_uefi()
|
|
|
|
# 1. Generate fstab
|
|
def get_uuid(dev):
|
|
res = run_command(["blkid", "-s", "UUID", "-o", "value", dev])
|
|
return res.stdout.strip()
|
|
|
|
root_uuid = get_uuid(partition_info["root"])
|
|
|
|
fstab_lines = [f"UUID={root_uuid} / ext4 defaults 1 1"]
|
|
|
|
if uefi and partition_info.get("efi"):
|
|
efi_uuid = get_uuid(partition_info["efi"])
|
|
# For systemd-boot, we mount ESP to /boot
|
|
fstab_lines.append(f"UUID={efi_uuid} /boot vfat defaults 0 2")
|
|
|
|
if partition_info.get("swap"):
|
|
swap_uuid = get_uuid(partition_info["swap"])
|
|
fstab_lines.append(f"UUID={swap_uuid} none swap defaults 0 0")
|
|
|
|
os.makedirs(os.path.join(mount_root, "etc"), exist_ok=True)
|
|
with open(os.path.join(mount_root, "etc/fstab"), "w") as f:
|
|
f.write("\n".join(fstab_lines) + "\n")
|
|
|
|
# Ensure EFI is mounted for bootloader installation if UEFI
|
|
if uefi and partition_info.get("efi"):
|
|
efi_target = os.path.join(mount_root, "boot")
|
|
os.makedirs(efi_target, exist_ok=True)
|
|
# Check if already mounted
|
|
res = subprocess.run(["mount"], capture_output=True, text=True)
|
|
if efi_target not in res.stdout:
|
|
run_command(["mount", partition_info["efi"], efi_target])
|
|
|
|
with mount_pseudo_fs(mount_root):
|
|
# 2. Configure User
|
|
if user_info:
|
|
logger.info(f"Creating user {user_info['username']}...")
|
|
|
|
# Since we rsync from live, we might have a 'liveuser' or similar.
|
|
# We should probably clear /home and /etc/passwd entries that are non-system
|
|
# but for now, let's just make sure we can create the new one.
|
|
try:
|
|
# Remove liveuser if it exists (common in Fedora live)
|
|
run_command(["chroot", mount_root, "userdel", "-r", "liveuser"], check=False)
|
|
except: pass
|
|
|
|
run_command(["chroot", mount_root, "useradd", "-m", "-G", "wheel", user_info["username"]])
|
|
|
|
# Set hostname
|
|
with open(os.path.join(mount_root, "etc/hostname"), "w") as f:
|
|
f.write(user_info["hostname"] + "\n")
|
|
|
|
# Set passwords
|
|
try:
|
|
res = subprocess.run(
|
|
["openssl", "passwd", "-6", user_info["password"]],
|
|
capture_output=True,
|
|
text=True,
|
|
check=True
|
|
)
|
|
hashed_pass = res.stdout.strip()
|
|
run_command(["chroot", mount_root, "usermod", "-p", hashed_pass, user_info["username"]])
|
|
run_command(["chroot", mount_root, "usermod", "-p", hashed_pass, "root"])
|
|
except Exception as e:
|
|
logger.error(f"Failed to set passwords: {e}")
|
|
|
|
# 3. Configure Bootloader
|
|
if uefi:
|
|
logger.info("Configuring systemd-boot...")
|
|
|
|
# Remove any copied machine-id to ensure a unique one is generated
|
|
mid_path = os.path.join(mount_root, "etc/machine-id")
|
|
if os.path.exists(mid_path):
|
|
os.remove(mid_path)
|
|
run_command(["chroot", mount_root, "systemd-machine-id-setup"])
|
|
|
|
os.makedirs(os.path.join(mount_root, "etc/kernel"), exist_ok=True)
|
|
with open(os.path.join(mount_root, "etc/kernel/cmdline"), "w") as f:
|
|
f.write(f"root=UUID={root_uuid} rw quiet\n")
|
|
|
|
with open(os.path.join(mount_root, "etc/kernel/layout"), "w") as f:
|
|
f.write("bls\n")
|
|
|
|
# Initialize systemd-boot
|
|
run_command(["chroot", mount_root, "bootctl", "install", "--path=/boot"])
|
|
|
|
# Sync kernels and generate BLS entries
|
|
# Since we rsync'd, kernels are in /lib/modules and /boot
|
|
# We use kernel-install to make sure they are properly set up for systemd-boot
|
|
modules_dir = os.path.join(mount_root, "lib/modules")
|
|
if os.path.exists(modules_dir):
|
|
kvers = [d for d in os.listdir(modules_dir) if os.path.isdir(os.path.join(modules_dir, d))]
|
|
for kver in kvers:
|
|
logger.info(f"Setting up boot entries for kernel {kver}...")
|
|
|
|
# Ensure initramfs exists in /boot (rsync should have copied it, but let's be sure)
|
|
initrd_path = f"/boot/initramfs-{kver}.img"
|
|
vmlinuz_path = f"/boot/vmlinuz-{kver}"
|
|
|
|
if not os.path.exists(os.path.join(mount_root, initrd_path.lstrip("/"))):
|
|
logger.info(f"Generating initramfs for {kver}...")
|
|
run_command(["chroot", mount_root, "dracut", "--force", initrd_path, kver])
|
|
|
|
# kernel-install add <version> <image> [initrd]
|
|
# On Fedora, kernel-install add will populate /boot/<machine-id>/<version>/
|
|
if os.path.exists(os.path.join(mount_root, vmlinuz_path.lstrip("/"))):
|
|
run_command(["chroot", mount_root, "kernel-install", "add", kver, vmlinuz_path])
|
|
else:
|
|
logger.info("Configuring GRUB2 (BIOS)...")
|
|
# Ensure /etc/default/grub exists
|
|
grub_default = os.path.join(mount_root, "etc/default/grub")
|
|
if not os.path.exists(grub_default):
|
|
with open(grub_default, "w") as f:
|
|
f.write('GRUB_TIMEOUT=5\nGRUB_DISTRIBUTOR="$(sed \'s, release .*$,,g\' /etc/system-release)"\nGRUB_DEFAULT=saved\nGRUB_DISABLE_SUBMENU=true\nGRUB_TERMINAL_OUTPUT="console"\nGRUB_CMDLINE_LINUX="rhgb quiet"\nGRUB_DISABLE_RECOVERY="true"\nGRUB_ENABLE_BLSCFG=true\n')
|
|
|
|
if not disk_device:
|
|
disk_device = partition_info["root"].rstrip("0123456789")
|
|
if disk_device.endswith("p"): disk_device = disk_device[:-1]
|
|
|
|
logger.info(f"Installing GRUB to {disk_device} (BIOS)")
|
|
run_command(["chroot", mount_root, "grub2-install", "--target=i386-pc", disk_device])
|
|
run_command(["chroot", mount_root, "grub2-mkconfig", "-o", "/boot/grub2/grub.cfg"])
|
|
|
|
run_command(["sync"])
|
|
|
|
logger.info("System configuration complete.")
|
|
log_os_install("CONFIGURE", "complete", "Bootloader and user configured successfully")
|