844 lines
31 KiB
Python
844 lines
31 KiB
Python
"""
|
|
* SPDX-FileCopyrightText: 2023-2025 PeppermintOS Team
|
|
* (peppermintosteam@proton.me)
|
|
* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*
|
|
* These functions will build the base of the fusato build folders
|
|
* As well as commonly used functions
|
|
"""
|
|
|
|
import os
|
|
import subprocess
|
|
import shutil
|
|
from python_modules.paths_modules import (
|
|
HOME_FOLDER, PACKAGE_LIST, CHROOT_FOLDER, INCLUDES_INSTALLER,
|
|
BOOTSTRAP_FOLDER, FUSATO_ROOT, DE_PATH, BUILD_FILE_PATH,
|
|
make_bootstrap_shared, make_packages_shared,
|
|
make_chroot_fusato_structure, make_chroot_installer_structure,
|
|
make_chroot_fusato_server, installer_server_dirs,
|
|
installer_mini_dirs
|
|
)
|
|
from python_modules.lists_modules import (
|
|
BINARY_LIST_SHARED, BINARY_LIST_64,
|
|
BINARY_LIST_ARM, BINARY_LIST_32
|
|
)
|
|
from python_modules.lists_modules import (
|
|
ENV_LIST, XFCE_LIST, DESKTOP_LIST, KDE_LIST, GNOME_FLASHBACK_LIST,
|
|
OPENBOX_LIST, LOADED_LIST, SERVER_LIST, MINI_LIST
|
|
)
|
|
from python_modules.lists_modules import (
|
|
FIRMWARE_LIST, FIRMWARE_LIST_ARM, FIRMWARE_LIST_32_64
|
|
)
|
|
from python_modules.lists_modules import (
|
|
GRUB_LIST_SHARED, GRUB_LIST_64, GRUB_LIST_ARM64, GRUB_LIST_32
|
|
)
|
|
from python_modules.lists_modules import (LIGHT_DM_LIST)
|
|
from python_modules.lists_modules import (GENERAL_SHARED_LIST)
|
|
from python_modules.lists_modules import (
|
|
system_list,system_list_64, system_list_arm64,system_list_32
|
|
)
|
|
from python_modules.lists_modules import (
|
|
ARTWORK_LIST, PYTHON_LIST, CALAMARES_LIST, GENERAL_LIST,
|
|
FLAG_SPECIFIC_LIST_32
|
|
)
|
|
|
|
from python_modules.logger_modules import builder_logger as logger
|
|
|
|
|
|
def recreate_directory(path):
|
|
"""
|
|
Recreate the fusato folder by removing it if it exists and then
|
|
creating it anew.
|
|
Args:
|
|
path (str): The full path of the directory to recreate.
|
|
Returns:
|
|
bool: True if the operation was successful, False otherwise.
|
|
"""
|
|
logger.info("Attempting to recreate directory: %s", path)
|
|
try:
|
|
if os.path.exists(path):
|
|
logger.debug("Directory exists, removing: %s", path)
|
|
shutil.rmtree(path, ignore_errors=True)
|
|
logger.info(
|
|
"Successfully removed existing directory: %s", path)
|
|
else:
|
|
logger.warning(
|
|
"Directory does not exist, will create new: %s", path)
|
|
os.makedirs(path)
|
|
logger.info("Successfully created new directory: %s", path)
|
|
return True
|
|
except OSError as _:
|
|
logger.error("Error recreating directory %s: %s", path, str(_))
|
|
return False
|
|
except (ValueError, TypeError)as _:
|
|
logger.critical(
|
|
"Unexpected error recreating directory %s: %s",
|
|
path, str(_))
|
|
return False
|
|
|
|
|
|
def create_folders(base_path, folder_list):
|
|
"""
|
|
This util function is a shared loop for bootstrap and packages
|
|
Arguments Passed from the other util functions
|
|
base_path (str): The base path where folders will be created.
|
|
folder_list (list): List of folder names to create.
|
|
"""
|
|
logger.info("Starting folder creation at base path: %s", base_path)
|
|
logger.info("Folder list to create: %s", folder_list)
|
|
for folder in folder_list:
|
|
full_path = os.path.join(base_path, folder)
|
|
logger.info("Attempting to create folder: %s", full_path)
|
|
try:
|
|
#os.makedirs(full_path, exist_ok=True)
|
|
subprocess.run(["mkdir", "-p", full_path], check=True)
|
|
logger.info(
|
|
"Successfully created/verified folder: %s", full_path)
|
|
except OSError as _:
|
|
logger.error(
|
|
"Error creating folder %s: %s", full_path, str(_))
|
|
exit()
|
|
except (ValueError, TypeError)as _:
|
|
logger.critical(
|
|
"Unexpected error creating folder %s: %s",
|
|
full_path, str(_))
|
|
exit()
|
|
logger.info("Folder creation process completed")
|
|
|
|
|
|
def create_bootstrap_folders():
|
|
"""Create bootstrap folders."""
|
|
logger.debug("Starting creation of bootstrap folders")
|
|
bootstrap_path = os.path.join(HOME_FOLDER, BOOTSTRAP_FOLDER)
|
|
logger.info("Bootstrap path: %s", bootstrap_path)
|
|
try:
|
|
create_folders(bootstrap_path, make_bootstrap_shared)
|
|
logger.info(
|
|
"Successfully created bootstrap folders at %s",
|
|
bootstrap_path)
|
|
except (ValueError, TypeError) as _:
|
|
logger.error("Error creating bootstrap folders: %s", str(_))
|
|
exit()
|
|
logger.info("Finished creating bootstrap folders")
|
|
|
|
|
|
def create_package_folders():
|
|
"""Create package folders."""
|
|
logger.debug("Starting creation of package folders")
|
|
package_path = os.path.join(HOME_FOLDER, PACKAGE_LIST)
|
|
logger.info("Package path: %s", package_path)
|
|
try:
|
|
create_folders(package_path, make_packages_shared)
|
|
logger.info("Successfully created package folders at %s", package_path)
|
|
except (ValueError, TypeError) as _:
|
|
logger.error("Error creating package folders: %s", str(_))
|
|
logger.info("Finished creating package folders")
|
|
|
|
|
|
def delete_fusato_folder(fusato_root):
|
|
"""Delete the fusato folder if it exists using sudo rm."""
|
|
if os.path.exists(fusato_root):
|
|
logger.info("Fusato folder exists. Deleting: %s", fusato_root)
|
|
try:
|
|
subprocess.run(['sudo', 'rm', '-rf', fusato_root], check=True)
|
|
logger.info("Fusato folder deleted successfully.")
|
|
except subprocess.CalledProcessError as e:
|
|
logger.error("Failed to delete fusato folder: %s", e)
|
|
else:
|
|
logger.info("Fusato folder does not exist: %s", fusato_root)
|
|
|
|
|
|
def set_fusato_structure():
|
|
"""
|
|
Make some needed folders for the fusato build process.
|
|
at this moment you deal with chroot and bootstrap
|
|
"""
|
|
logger.debug("Starting to set up Fusato structure")
|
|
try:
|
|
fusato_root = os.path.join(HOME_FOLDER, FUSATO_ROOT)
|
|
delete_fusato_folder(fusato_root)
|
|
logger.info("Fusato root path: %s", fusato_root)
|
|
logger.info("Changed directory to Fusato root")
|
|
config_path = os.path.join(fusato_root, 'config')
|
|
logger.info("Config path: %s", config_path)
|
|
if not recreate_directory(config_path):
|
|
logger.warning(
|
|
"Failed to recreate config directory: %s", config_path)
|
|
exit()
|
|
for folder in make_chroot_fusato_structure:
|
|
chroot_folder_path = os.path.join(
|
|
HOME_FOLDER, CHROOT_FOLDER, folder)
|
|
logger.info("Creating chroot folder: %s",
|
|
chroot_folder_path)
|
|
os.makedirs(chroot_folder_path, exist_ok=True)
|
|
logger.debug("Creating bootstrap folders")
|
|
create_bootstrap_folders()
|
|
logger.debug("Creating package folders")
|
|
create_package_folders()
|
|
logger.info("Fusato structure set up successfully")
|
|
except OSError as _:
|
|
logger.error("Error setting up fusato structure: %s", str(_))
|
|
exit()
|
|
raise
|
|
except (ValueError, TypeError) as _:
|
|
logger.critical(
|
|
"Unexpected error setting up fusato structure: %s", str(_))
|
|
exit()
|
|
raise
|
|
|
|
|
|
def set_fusato_server_structure():
|
|
""" Make some needed folders for the fusato build process.
|
|
at the moment you deal with chroot, bootstrap, and
|
|
includes-installer
|
|
"""
|
|
logger.info("Starting to set up Fusato server structure")
|
|
try:
|
|
fusato_root = os.path.join(HOME_FOLDER, FUSATO_ROOT)
|
|
logger.debug("Fusato root path: %s", fusato_root)
|
|
os.chdir(fusato_root)
|
|
logger.debug("Changed directory to Fusato root")
|
|
config_path = os.path.join(fusato_root, 'config')
|
|
logger.debug("Config path: %s", config_path)
|
|
if not recreate_directory(config_path):
|
|
logger.warning(
|
|
"Failed to recreate config directory: %s", config_path)
|
|
for folder in make_chroot_fusato_server:
|
|
chroot_folder_path = os.path.join(HOME_FOLDER,
|
|
CHROOT_FOLDER, folder)
|
|
logger.debug("Creating chroot folder: %s",
|
|
chroot_folder_path)
|
|
os.makedirs(chroot_folder_path, exist_ok=True)
|
|
logger.info("Creating bootstrap folders")
|
|
create_bootstrap_folders()
|
|
logger.info("Creating package folders")
|
|
create_package_folders()
|
|
logger.info("Fusato server structure set up successfully")
|
|
except OSError as _:
|
|
logger.error(
|
|
"Error setting up fusato server structure: %s", str(_))
|
|
exit()
|
|
raise
|
|
except (ValueError, TypeError) as _:
|
|
logger.critical(
|
|
"Unexpected error setting up fusato server structure: %s",
|
|
str(_))
|
|
exit()
|
|
raise
|
|
|
|
|
|
def set_fusato_server_installer_structure():
|
|
""" Make some needed folders for the fusato build process.
|
|
at the moment you deal with the installer
|
|
Define the directories to be created in includes-installer
|
|
Create the directories in includes-installer
|
|
"""
|
|
logger.info("Starting to set up Fusato server installer structure")
|
|
for server_dir in installer_server_dirs:
|
|
full_path = os.path.join(HOME_FOLDER, INCLUDES_INSTALLER,
|
|
server_dir.strip('/'))
|
|
logger.debug("Creating directory: %s", full_path)
|
|
try:
|
|
os.makedirs(full_path, exist_ok=True)
|
|
logger.info("Created directory: %s", full_path)
|
|
except OSError as _:
|
|
logger.error("Error creating directory %s: %s", full_path,
|
|
str(_))
|
|
exit()
|
|
logger.info("Finished setting up Fusato server installer structure")
|
|
|
|
|
|
def set_fusato_mini_structure():
|
|
""" Make some needed folders for the fusato build process.
|
|
at the moment you deal with chroot, bootstrap, and
|
|
includes-installer
|
|
"""
|
|
logger.debug("Starting to set up Fusato mini structure")
|
|
try:
|
|
fusato_root = os.path.join(HOME_FOLDER, FUSATO_ROOT)
|
|
delete_fusato_folder(fusato_root)
|
|
logger.info("Fusato root path: %s", fusato_root)
|
|
config_path = os.path.join(fusato_root, 'config')
|
|
logger.info("Config path: %s", config_path)
|
|
if not recreate_directory(config_path):
|
|
logger.warning(
|
|
"Failed to recreate config directory: %s", config_path)
|
|
exit()
|
|
for folder in make_chroot_fusato_structure:
|
|
chroot_folder_path = os.path.join(
|
|
HOME_FOLDER, CHROOT_FOLDER, folder)
|
|
logger.info("Creating chroot folder: %s",
|
|
chroot_folder_path)
|
|
os.makedirs(chroot_folder_path, exist_ok=True)
|
|
logger.debug("Changed directory to Fusato root")
|
|
os.chdir(fusato_root)
|
|
logger.debug("Creating bootstrap folders")
|
|
create_bootstrap_folders()
|
|
logger.debug("Creating package folders")
|
|
create_package_folders()
|
|
logger.info("Fusato mini structure set up successfully")
|
|
except OSError as _:
|
|
logger.error(
|
|
"Error setting up fusato mini structure: %s", str(_))
|
|
exit()
|
|
raise
|
|
except (ValueError, TypeError) as _:
|
|
logger.critical(
|
|
"Unexpected error setting up fusato mini structure: %s",
|
|
str(_))
|
|
exit()
|
|
raise
|
|
|
|
|
|
def set_fusato_mini_installer_structure():
|
|
""" Make some needed folders for the fusato build process.
|
|
at the moment you deal with the installer. Define the
|
|
directories to be created in includes-installer
|
|
Create the directories in includes-installer
|
|
"""
|
|
print("catchme")
|
|
logger.info("Starting to set up Fusato mini installer structure")
|
|
try:
|
|
fusato_root = os.path.join(HOME_FOLDER, FUSATO_ROOT)
|
|
except OSError as _:
|
|
logger.error("Error creating directory %s: %s", full_path,
|
|
str(_))
|
|
exit()
|
|
for mine_dir in installer_mini_dirs:
|
|
full_path = os.path.join(HOME_FOLDER, INCLUDES_INSTALLER, mine_dir.strip('/'))
|
|
logger.debug("Creating directory: %s", full_path)
|
|
try:
|
|
os.makedirs(full_path, exist_ok=True)
|
|
logger.info("Created directory: %s", full_path)
|
|
except OSError as _:
|
|
logger.error("Error creating directory %s: %s", full_path,
|
|
str(_))
|
|
exit()
|
|
logger.info("Finished setting up Fusato mini installer structure")
|
|
|
|
|
|
def set_fusato_installer_structure():
|
|
"""
|
|
Make the fusato installer structure
|
|
"""
|
|
logger.debug("Starting to set up Fusato installer structure")
|
|
try:
|
|
fusato_root_path = os.path.join(HOME_FOLDER, FUSATO_ROOT)
|
|
os.chdir(fusato_root_path)
|
|
logger.info("Changed directory to: %s", fusato_root_path)
|
|
except (ValueError, TypeError, IOError, OSError) as _:
|
|
logger.error("Error changing directory: %s", str(_))
|
|
exit()
|
|
return
|
|
for folder in make_chroot_installer_structure:
|
|
full_path = os.path.join(HOME_FOLDER,
|
|
CHROOT_FOLDER.strip('/'), folder.strip('/'))
|
|
logger.info("Attempting to create directory: %s", full_path)
|
|
try:
|
|
os.makedirs(full_path, exist_ok=True)
|
|
logger.info("Created directory: %s", full_path)
|
|
except (ValueError, TypeError, IOError, OSError) as _:
|
|
logger.error("Error creating directory %s: %s", full_path,
|
|
str(_))
|
|
exit()
|
|
logger.info("Finished setting up Fusato installer structure")
|
|
|
|
|
|
def make_build_file(base, arch, extension, build_description):
|
|
"""
|
|
This will get the base, arch, extension, and build, to write the
|
|
file
|
|
"""
|
|
logger.info("Starting to create build file for %s %s", base, arch)
|
|
file_path = os.path.join(os.path.expanduser(HOME_FOLDER),
|
|
FUSATO_ROOT, f'{base}.{arch}{extension}'
|
|
)
|
|
logger.debug("Build file path: %s", file_path)
|
|
try:
|
|
with open(file_path, 'w', encoding='UTF-8') as f_p:
|
|
f_p.write(build_description)
|
|
logger.info("Successfully created build file: %s", file_path)
|
|
except IOError as _:
|
|
logger.error("Error writing build file %s: %s", file_path,
|
|
str(_))
|
|
exit()
|
|
except (ValueError, TypeError) as _:
|
|
logger.critical("Unexpected error creating build file %s: %s",
|
|
file_path, str(_))
|
|
exit()
|
|
logger.info("Finished creating build file for %s %s", base, arch)
|
|
|
|
|
|
def make_bld_xfce(base, arch):
|
|
"""Write the xfce build file"""
|
|
logger.info("Creating XFCE build file for %s %s", base, arch)
|
|
make_build_file(base, arch, 'xfc', 'XFCE Build')
|
|
logger.info("XFCE build file created for %s %s", base, arch)
|
|
|
|
|
|
def make_bld_gnomeflashback(base, arch):
|
|
"""Write the gnome fb build file"""
|
|
logger.info("Creating Gnome Flashback build file for %s %s", base,
|
|
arch)
|
|
make_build_file(base, arch, 'gfb', 'Gnome Flash Back Build')
|
|
logger.info("Gnome Flashback build file created for %s %s", base,
|
|
arch)
|
|
|
|
|
|
def make_bld_openbox(base, arch):
|
|
"""Write the openbox build file"""
|
|
logger.info("Creating OpenBox build file for %s %s", base, arch)
|
|
make_build_file(base, arch, 'opb', 'OpenBox Build')
|
|
logger.info("OpenBox build file created for %s %s", base, arch)
|
|
|
|
|
|
def make_bld_kde(base, arch):
|
|
"""Write the kde build file"""
|
|
logger.info("Creating KDE build file for %s %s", base, arch)
|
|
make_build_file(base, arch, 'kde', 'KDE Build')
|
|
logger.info("KDE build file created for %s %s", base, arch)
|
|
|
|
|
|
def make_bld_loaded(base, arch):
|
|
"""Write the loaded build file"""
|
|
logger.info("Creating Loaded build file for %s %s", base, arch)
|
|
make_build_file(base, arch, 'loaded', 'Loaded Build')
|
|
logger.info("Loaded build file created for %s %s", base, arch)
|
|
|
|
|
|
def make_bld_server(base, arch):
|
|
"""Write the server build file"""
|
|
logger.info("Creating Server build file for %s %s", base, arch)
|
|
make_build_file(base, arch, 'server', 'Server Build')
|
|
logger.info("Server build file created for %s %s", base, arch)
|
|
|
|
|
|
def make_bld_mini(base, arch):
|
|
"""Write the mini build file"""
|
|
logger.info("Creating Mini build file for %s %s", base, arch)
|
|
make_build_file(base, arch, 'mini', 'Mini Build')
|
|
logger.info("Mini build file created for %s %s", base, arch)
|
|
|
|
|
|
def make_package_list(file_name, content, mode='a'):
|
|
"""Create the package list file with the specified content if it
|
|
doesn't exist.
|
|
"""
|
|
logger.info("Starting to create package list: %s", file_name)
|
|
file_path = os.path.join(HOME_FOLDER, PACKAGE_LIST, file_name)
|
|
logger.info("Package list file path: %s", file_path)
|
|
if not os.path.exists(file_path):
|
|
try:
|
|
with open(file_path, mode, encoding='UTF-8') as f_p:
|
|
f_p.write(content)
|
|
logger.info("Created package list: %s", file_path)
|
|
except IOError as _:
|
|
logger.error("Error creating package list %s: %s",
|
|
file_path, str(_))
|
|
exit()
|
|
except (ValueError, TypeError) as _:
|
|
logger.critical(
|
|
"Unexpected error creating package list %s: %s",
|
|
file_path, str(_))
|
|
exit()
|
|
else:
|
|
logger.info("Package list already exists: %s", file_path)
|
|
logger.debug("Finished processing package list: %s", file_name)
|
|
|
|
|
|
def set_general_shared():
|
|
""" Create the list for general shared list"""
|
|
logger.debug("Creating general shared list")
|
|
package_list_string = "\n".join(GENERAL_SHARED_LIST)
|
|
make_package_list('genshared.list.chroot', package_list_string, mode='x')
|
|
logger.info("General shared list created")
|
|
|
|
|
|
def set_specific_32_packages():
|
|
"""Create the list for the 32bit flagship"""
|
|
logger.info("Creating 32-bit specific package list")
|
|
package_list_string = "\n".join(FLAG_SPECIFIC_LIST_32)
|
|
make_package_list('flagspec32.list.chroot', package_list_string,
|
|
mode='x')
|
|
logger.info("32-bit specific package list created")
|
|
|
|
|
|
def set_grub_shared():
|
|
""" Create the list for shared grub list"""
|
|
logger.info("Creating shared GRUB list")
|
|
package_list_string = "\n".join(GRUB_LIST_SHARED)
|
|
make_package_list('grub.list.chroot', package_list_string, mode='x')
|
|
logger.info("Shared GRUB list created")
|
|
|
|
|
|
def set_binary_shared():
|
|
""" Create the shared list for grub binary"""
|
|
logger.info("Creating shared binary list")
|
|
package_list_string = "\n".join(BINARY_LIST_SHARED)
|
|
make_package_list('installer.list.binary', package_list_string,
|
|
mode='x')
|
|
logger.info("Shared binary list created")
|
|
|
|
|
|
def set_lightdm():
|
|
""" Create the list for the light dm list """
|
|
logger.info("Creating LightDM package list")
|
|
package_list_string = "\n".join(LIGHT_DM_LIST)
|
|
make_package_list('lightdm.list.chroot', package_list_string, mode='x')
|
|
logger.info("LightDM package list created")
|
|
|
|
|
|
def set_xfce():
|
|
""" Create the list for the xfce xfce list"""
|
|
logger.info("Creating XFCE package list")
|
|
package_list_string = "\n".join(XFCE_LIST)
|
|
make_package_list('xfce.list.chroot', package_list_string, mode='x')
|
|
logger.info("XFCE package list created")
|
|
|
|
|
|
def set_gfb():
|
|
""" Create the list for the gnomeflashback list"""
|
|
logger.info("Creating GNOME Flashback package list")
|
|
package_list_string = "\n".join(GNOME_FLASHBACK_LIST)
|
|
make_package_list('gfb.list.chroot', package_list_string , mode='x')
|
|
logger.info("GNOME Flashback package list created")
|
|
|
|
|
|
def set_opb():
|
|
""" Create the list for the openbox list"""
|
|
logger.info("Creating Openbox package list")
|
|
package_list_string = "\n".join(OPENBOX_LIST)
|
|
make_package_list('opb.list.chroot', package_list_string, mode='x')
|
|
logger.info("Openbox package list created")
|
|
|
|
|
|
def set_kde():
|
|
""" Create the list file for the kde list"""
|
|
logger.info("Creating KDE package list")
|
|
package_list_string = "\n".join(KDE_LIST)
|
|
make_package_list('kde.list.chroot', package_list_string, mode='x')
|
|
logger.info("KDE package list created")
|
|
|
|
|
|
def set_loaded():
|
|
""" Create the list for the loaded list"""
|
|
logger.info("Creating Loaded package list")
|
|
package_list_string = "\n".join(LOADED_LIST)
|
|
make_package_list('loaded.list.chroot', package_list_string, mode='x')
|
|
logger.info("Loaded package list created")
|
|
|
|
|
|
def set_server():
|
|
""" Create the list for the server list"""
|
|
logger.info("Creating Server package list")
|
|
package_list_string = "\n".join(SERVER_LIST)
|
|
make_package_list('server.list.chroot', package_list_string, mode='x')
|
|
logger.info("Server package list created")
|
|
|
|
|
|
def set_mini():
|
|
""" Create the list for the loaded list"""
|
|
logger.info("Creating Mini package list")
|
|
package_list_string = "\n".join(MINI_LIST)
|
|
print(package_list_string)
|
|
make_package_list('mini.list.chroot', package_list_string, mode='x')
|
|
logger.info("Mini package list created")
|
|
|
|
|
|
def set_chroot_grub_64():
|
|
""" Append the grub list for 64 bit grub"""
|
|
logger.info("Appending 64-bit GRUB list")
|
|
package_list_string = "\n".join(GRUB_LIST_64)
|
|
make_package_list('gfb.list.chroot', package_list_string)
|
|
logger.info("64-bit GRUB list appended")
|
|
|
|
|
|
def set_chroot_grub_arm():
|
|
""" Append the grub list for the ARM grub"""
|
|
logger.info("Appending ARM GRUB list")
|
|
package_list_string = "\n".join(GRUB_LIST_ARM64)
|
|
make_package_list('gfb.list.chroot', package_list_string)
|
|
logger.info("ARM GRUB list appended")
|
|
|
|
|
|
def set_chroot_grub_32():
|
|
""" Append the grub list for the 32 bit grub"""
|
|
logger.info("Appending 32-bit GRUB list")
|
|
package_list_string = "\n".join(GRUB_LIST_32)
|
|
make_package_list('gfb.list.chroot', package_list_string)
|
|
logger.info("32-bit GRUB list appended")
|
|
|
|
|
|
def set_binary_64():
|
|
""" Create the list for grub binary packages for 64 bit"""
|
|
logger.info("Creating 64-bit binary package list")
|
|
package_list_string = "\n".join(BINARY_LIST_64)
|
|
make_package_list('installer.list.binary', package_list_string)
|
|
logger.info("64-bit binary package list created")
|
|
|
|
|
|
|
|
def set_binary_arm():
|
|
""" Create the list for grub binary packages for ARM"""
|
|
logger.info("Creating ARM binary package list")
|
|
package_list_string = "\n".join(BINARY_LIST_ARM)
|
|
make_package_list('installer.list.binary', package_list_string)
|
|
logger.info("ARM binary package list created")
|
|
|
|
|
|
def set_binary_32():
|
|
""" Create the list for grub binary packages for 32 bit"""
|
|
logger.info("Creating 32-bit binary package list")
|
|
package_list_string = "\n".join(BINARY_LIST_32)
|
|
make_package_list('installer.list.binary', package_list_string)
|
|
logger.info("32-bit binary package list created")
|
|
|
|
|
|
def set_firmware():
|
|
""" Create the list for the firmware support for general ISOs"""
|
|
logger.info("Creating firmware list for general ISOs")
|
|
package_list_string = "\n".join(FIRMWARE_LIST_32_64)
|
|
make_package_list('firmware.list.chroot', package_list_string, mode='x')
|
|
logger.info("Firmware list for general ISOs created")
|
|
|
|
|
|
def set_firmware_arm():
|
|
""" Create the list for the firmware support for arm ISOs"""
|
|
logger.info("Creating firmware list for ARM ISOs")
|
|
package_list_string = "\n".join(FIRMWARE_LIST_ARM)
|
|
make_package_list('firmware.list.chroot', package_list_string, mode='x')
|
|
logger.info("Firmware list for ARM ISOs created")
|
|
|
|
|
|
def set_desktop_environment():
|
|
""" Create the list for the desktop environment"""
|
|
logger.info("Starting to create desktop environment list")
|
|
try:
|
|
os.chdir(HOME_FOLDER)
|
|
logger.debug("Changed directory to: %s", HOME_FOLDER)
|
|
current_dir = os.getcwd().replace('/', '/')
|
|
logger.debug("Current directory: %s", current_dir)
|
|
package_lists_dir = current_dir + DE_PATH
|
|
os.chdir(package_lists_dir)
|
|
logger.debug("Changed directory to package-lists: %s",
|
|
package_lists_dir)
|
|
desktop_list_file = 'desktop.list.chroot'
|
|
logger.info("Creating desktop environment list file: %s",
|
|
desktop_list_file)
|
|
with open(desktop_list_file, 'x', encoding='UTF-8') as de_file:
|
|
de_file.write(ENV_LIST)
|
|
logger.info(
|
|
"Desktop environment list file created successfully")
|
|
except FileExistsError:
|
|
logger.warning(
|
|
"Desktop environment list file already exists: %s",
|
|
desktop_list_file)
|
|
exit()
|
|
except IOError as _:
|
|
logger.error(
|
|
"Error creating desktop environment list file: %s",
|
|
str(_))
|
|
exit()
|
|
except (ValueError, TypeError) as _:
|
|
logger.critical(
|
|
"Unexpected error in set_desktop_environment: %s", str(_))
|
|
exit()
|
|
logger.info("Finished creating desktop environment list")
|
|
|
|
|
|
def set_extra_packages():
|
|
""" Create the list for the desktop environment extras goodies"""
|
|
with open(
|
|
'extra-desktop.list.chroot', 'x', encoding='UTF-8'
|
|
) as extra_file:
|
|
extra_file.write(DESKTOP_LIST)
|
|
|
|
|
|
def set_general_packages():
|
|
""" Create the list for standard install packages"""
|
|
logger.info("Creating general packages list")
|
|
try:
|
|
with open(
|
|
'packages.list.chroot', 'x',
|
|
encoding='UTF-8') as general_file:
|
|
general_file.write(GENERAL_LIST)
|
|
logger.info("General packages list created successfully")
|
|
except IOError as _:
|
|
logger.error("Error creating general packages list: %s", str(_))
|
|
exit()
|
|
|
|
|
|
def set_system_packages():
|
|
""" Create the list for system management packages"""
|
|
logger.info("Creating system packages list")
|
|
try:
|
|
with open('system.list.chroot', 'x',
|
|
encoding='UTF-8') as system_file:
|
|
system_file.write(system_list)
|
|
logger.info("System packages list created successfully")
|
|
except IOError as _:
|
|
logger.error("Error creating system packages list: %s", str(_))
|
|
exit()
|
|
|
|
|
|
def set_system_packages_32():
|
|
""" Create the list for system management packages"""
|
|
logger.info("Appending 32-bit system packages list")
|
|
try:
|
|
with open('system.list.chroot', 'a',
|
|
encoding='UTF-8') as system_file:
|
|
system_file.write(system_list_32)
|
|
logger.info("32-bit system packages list appended successfully")
|
|
except IOError as _:
|
|
logger.error(
|
|
"Error appending 32-bit system packages list: %s", str(_))
|
|
exit()
|
|
|
|
|
|
def set_system_packages_64():
|
|
""" Create the list for system management packages"""
|
|
logger.info("Appending 64-bit system packages list")
|
|
try:
|
|
with open('system.list.chroot', 'a',
|
|
encoding='UTF-8') as system_file:
|
|
system_file.write(system_list_64)
|
|
logger.info("64-bit system packages list appended successfully")
|
|
exit()
|
|
except IOError as _:
|
|
logger.error(
|
|
"Error appending 64-bit system packages list: %s", str(_))
|
|
exit()
|
|
|
|
|
|
def set_system_packages_arm():
|
|
""" Create the list for system management packages"""
|
|
logger.info("Appending ARM system packages list")
|
|
try:
|
|
with open('system.list.chroot', 'a',
|
|
encoding='UTF-8') as system_file:
|
|
system_file.write(system_list_arm64)
|
|
logger.info("ARM system packages list appended successfully")
|
|
except IOError as _:
|
|
logger.error("Error appending ARM system packages list: %s",
|
|
str(_))
|
|
exit()
|
|
|
|
|
|
def set_artwork_packages():
|
|
""" Create the list for icons, wallpaper and themes"""
|
|
logger.info("Creating artwork packages list")
|
|
try:
|
|
with open('artwork.list.chroot', 'x',
|
|
encoding='UTF-8') as artwork_file:
|
|
artwork_file.write(ARTWORK_LIST)
|
|
logger.info("Artwork packages list created successfully")
|
|
except IOError as _:
|
|
logger.error("Error creating artwork packages list: %s", str(_))
|
|
exit()
|
|
|
|
|
|
def set_python_packages():
|
|
""" Create the list for python related needs"""
|
|
logger.info("Creating Python packages list")
|
|
try:
|
|
with open('python.list.chroot', 'x',
|
|
encoding='UTF-8') as python_file:
|
|
python_file.write(PYTHON_LIST)
|
|
logger.info("Python packages list created successfully")
|
|
except IOError as _:
|
|
logger.error("Error creating Python packages list: %s", str(_))
|
|
exit()
|
|
|
|
|
|
def set_calamares_packages():
|
|
""" Create the list for the calamares installer"""
|
|
logger.info("Creating Calamares packages list")
|
|
try:
|
|
with open('installer.list.chroot', 'x',
|
|
encoding='UTF-8') as calamares_file:
|
|
calamares_file.write(CALAMARES_LIST)
|
|
logger.info("Calamares packages list created successfully")
|
|
except IOError as _:
|
|
logger.error("Error creating Calamares packages list: %s",
|
|
str(_))
|
|
exit()
|
|
|
|
|
|
def set_firmware_packages():
|
|
""" Create the list for the firmware support for general ISOs"""
|
|
logger.info("Creating firmware packages list for general ISOs")
|
|
try:
|
|
with open('firmware.list.chroot', 'x',
|
|
encoding='UTF-8') as firmware_file:
|
|
firmware_file.write(FIRMWARE_LIST)
|
|
logger.info("Firmware packages list for general ISOs created successfully")
|
|
except IOError as _:
|
|
logger.error(
|
|
"Error creating firmware packages list for general ISOs: %s",
|
|
str(_))
|
|
exit()
|
|
|
|
|
|
def set_firmware_packages_arm():
|
|
""" Create the list for the firmware support for arm ISOs"""
|
|
logger.info("Creating firmware packages list for ARM ISOs")
|
|
try:
|
|
with open('firmware.list.chroot', 'x',
|
|
encoding='UTF-8') as firmware_file:
|
|
firmware_file.write(FIRMWARE_LIST_ARM)
|
|
logger.info(
|
|
"Firmware packages list for ARM ISOs created successfully")
|
|
except IOError as _:
|
|
logger.error(
|
|
"Error creating firmware packages list for ARM ISOs: %s",
|
|
str(_))
|
|
exit()
|
|
|
|
|
|
def set_binary_packages_64():
|
|
""" Create the list for grub binary packages for 64 bit"""
|
|
logger.info("Creating binary packages list for 64-bit")
|
|
try:
|
|
with open('installer.list.binary', 'x',
|
|
encoding='UTF-8') as binary_file:
|
|
binary_file.write(BINARY_LIST_64)
|
|
logger.info(
|
|
"Binary packages list for 64-bit created successfully")
|
|
except IOError as _:
|
|
logger.error(
|
|
"Error creating binary packages list for 64-bit: %s",
|
|
str(_))
|
|
exit()
|
|
|
|
|
|
def set_binary_packages_arm64():
|
|
""" Create the list for grub binary packages for 64 bit"""
|
|
logger.info("Creating binary packages list for ARM64")
|
|
try:
|
|
with open('installer.list.binary', 'x',
|
|
encoding='UTF-8') as binary_file:
|
|
binary_file.write(BINARY_LIST_ARM)
|
|
logger.info(
|
|
"Binary packages list for ARM64 created successfully")
|
|
except IOError as _:
|
|
logger.error(
|
|
"Error creating binary packages list for ARM64: %s", str(_))
|
|
exit()
|
|
|
|
|
|
def set_binary_packages_32():
|
|
""" Create the list for grub binary packages for 32 bit"""
|
|
logger.info("Creating binary packages list for 32-bit")
|
|
try:
|
|
with open('installer.list.binary', 'x',
|
|
encoding='UTF-8') as binary_file:
|
|
binary_file.write(BINARY_LIST_32)
|
|
logger.info(
|
|
"Binary packages list for 32-bit created successfully")
|
|
except IOError as _:
|
|
logger.error(
|
|
"Error creating binary packages list for 32-bit: %s",
|
|
str(_))
|
|
exit()
|
|
|