bubbles/python_modules/infra.py

"""
* Author: "PeppermintOS Team(peppermintosteam@proton.me)
*
* License: SPDX-License-Identifier: GPL-3.0-or-later
*
* Set the infrastructure for bubbles to begin the ISO build
* This copies needed config files to the binary and chroot
* locations, based on the build base and architecture
"""
import os
import collections
from pathlib import Path
import shutil
import logging
import conf



# Public Variables used in the classes
BSTRING_ISO_CONFIGS = '~/bubbles/iso_configs'
HOME_FOLDER = str(Path(BSTRING_ISO_CONFIGS).expanduser())
WPCHROOT = "/fusato/config/includes.chroot"
WPINSTALLER = "/fusato/config/includes.installer"
BINARYPTH = "/fusato/config/includes.binary"
BOOTSTRAP = "/fusato/config/includes.bootstrap"
FUSATOCONFIG = "/fusato/config"

# Set up the logging format
logger = logging.getLogger()
MSG_COPY = "Copying  - "
MSG_FIN = "Finished - "


class Archive:
    """
    Copy the multimedia to the ARCHIVES folder Depending on 
    the architecture it will, copy folders as needed 
    """
    def __init__(self,sbase,sarch):
        logger.info("Copy Archive")
        self.sbase = sbase
        self.sarch = sarch
        src_archive = ('/multimedia/' + self.sbase + self.sarch,)
        des_archive =('/archives',)
        # Archives Folders.
        archive_src_q = collections.deque(src_archive)
        archive_des_q = collections.deque(des_archive)
        archive_size_q = len(archive_src_q)
        for size_length in range(archive_size_q):
            source = archive_src_q.popleft()
            des = archive_des_q.popleft()
            logger.info(MSG_COPY + HOME_FOLDER + source)
            shutil.copytree(HOME_FOLDER + source,
                            HOME_FOLDER + FUSATOCONFIG + des,
                            dirs_exist_ok = True
                            )
            logger.info(MSG_FIN + HOME_FOLDER + FUSATOCONFIG + des)


class ChrootFolders:
    """ 
        Copy all the needed folders to CHROOT Depending on 
        the architecture it will, copy folders as needed 
    """
    # It would be better to move the calamares and /opt/pepconf files to a def or other solution since they are not necessary in server builds.
    # Mini builds are not affected because the chroot is deleted in the binary phase.
    def __init__(self,sbase,sarch):
        logger.info("Copy Chroot")
        self.sbase = sbase
        self.sarch = sarch
        src_chroot = ('/osrelease/' + self.sbase + self.sarch,
                      #'/osrelease/' + self.sbase + self.sarch,
                      '/grub/'+ self.sbase + self.sarch,
                      #'/calamares_settings/' + self.sbase  +  self.sarch  +
                      #'/calamares/modules',
                      '/grub/' + self.sbase + '_themes'
                      )
        des_chroot =('/usr/lib',
                     '/opt/pepconf',
                     #'/etc/default',
                     #'/etc/calamares/modules',
                     '/boot/grub/themes'
                     )
        # Chroot Folders.
        chroot_src_q = collections.deque(src_chroot)
        chroot_des_q = collections.deque(des_chroot)
        chroot_size_q = len(chroot_src_q)
        for size_length in range(chroot_size_q):
            source = chroot_src_q.popleft()
            des = chroot_des_q.popleft()
            logger.info(MSG_COPY + HOME_FOLDER + source)
            shutil.copytree(HOME_FOLDER + source,
                            HOME_FOLDER + WPCHROOT + des,
                            dirs_exist_ok = True
                            )
            logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des)


class BinaryFolders:
    """ 
        Copy all the needed folders to BINARY Depending on
        the architecture it will, copy folders as needed
    """
    def __init__(self, sbase, sarch):

        logger.info("Copy Binary")
        self.sbase = sbase
        self.sarch = sarch
        src_binary = ('/splash/' + self.sbase + self.sarch + '/boot',
                      '/splash/' + self.sbase + self.sarch +'/isolinux',
                      '/splash/' + self.sbase + '_live-theme',
                      '/splash/' + self.sbase + '_splash',
                      '/splash/' + self.sbase + '_splash'
                      )
        des_binary =('/boot',
                     '/isolinux',
                     '/boot/grub',
                     '/isolinux',
                     '/boot/grub'
                     )
        # Binary Folders
        binary_src_q = collections.deque(src_binary)
        binary_des_q = collections.deque(des_binary)
        binary_size_q = len(binary_src_q)
        for size_length in range(binary_size_q):
            source = binary_src_q.popleft()
            des = binary_des_q.popleft()
            logger.info(MSG_COPY+ HOME_FOLDER + source)
            shutil.copytree(HOME_FOLDER + source,
                             HOME_FOLDER + BINARYPTH + des,
                             dirs_exist_ok = True
                             )
            logger.info(MSG_FIN + HOME_FOLDER + BINARYPTH + des)

class FusatoConfigs:
    """
        Copy all the needed files to the hooks folders depending on
        the architecture it will, copy folders as needed
    """
    def __init__(self,sbase,sarch):
        logger.info("Copy Hooks Files")
        self.sbase = sbase
        self.sarch = sarch
        src_fusatoconfig = ('/hooks/normal/'+ self.sbase + self.sarch,)
        des_fusatoconfig = ('/hooks/normal/',)
        # Fusatoconfig FIles
        fusatoconfig_src_q = collections.deque(src_fusatoconfig)
        fusatoconfig_des_q = collections.deque(des_fusatoconfig)
        fusatoconfig_size_q = len(fusatoconfig_src_q)
        for size_length in range(fusatoconfig_size_q):
            source = fusatoconfig_src_q.popleft()
            des = fusatoconfig_des_q.popleft()
            logger.info(MSG_COPY+ HOME_FOLDER + source)
            shutil.copytree(HOME_FOLDER + source,
                             HOME_FOLDER + FUSATOCONFIG + des,
                             dirs_exist_ok = True
                             )
            logger.info(MSG_FIN + HOME_FOLDER + FUSATOCONFIG + des)

class InstallerFiles:
    """
        Copy all the needed files to the installer depending on
        the architecture it will, copy folders as needed
    """
    def __init__(self,sbase,sarch):
        logger.info("Copy Installer Files")
        self.sbase = sbase
        self.sarch = sarch
        src_installer = ('/installer/preseed/'+ self.sbase + self.sarch,
                         '/installer/artwork/' + self.sbase + self.sarch,
                         '/installer/scripts/'+ self.sbase + self.sarch,
                         '/installer/grub/'+ self.sbase + self.sarch,
                         '/installer/sources/'+ self.sbase + self.sarch,
                         '/installer/sources/'+ self.sbase + self.sarch,
                         '/osrelease/'+ self.sbase + self.sarch,
                          )
        des_installer =('/',
                        '/usr/share/',
                        '/usr/lib/finish-install.d/',
                        '/preseed/grub/',
                        '/preseed/repos/',
                        '/preseed/conf/',
                        '/preseed/conf/',
                        )
        # installer FIles
        installer_src_q = collections.deque(src_installer)
        installer_des_q = collections.deque(des_installer)
        installer_size_q = len(installer_src_q)
        for size_length in range(installer_size_q):
            source = installer_src_q.popleft()
            des = installer_des_q.popleft()
            logger.info(MSG_COPY+ HOME_FOLDER + source)
            shutil.copytree(HOME_FOLDER + source,
                             HOME_FOLDER + WPINSTALLER + des,
                             dirs_exist_ok = True
                             )
            logger.info(MSG_FIN + HOME_FOLDER + WPINSTALLER + des)

def mini_installer_folders():
    """ 
        This function will get the files that are shared commonly amongst 
        all server builds, 
    """

    logger.info("Copy mini installer folders")

    src_paths = ('/installer/keyrings/',
                 '/installer/applications/',
                 '/database/',
                 '/PepProPixMaps/',
                 '/pmostools/',
                 '/PepProTools/',
                 '/polkit/',
                 '/issue/',
                 '/pylibraries/',
                 '/lightdm/',
                 '/autostart'
                 )
    des_paths =('/preseed/keyrings/',
                '/preseed/apps/',
                '/preseed/database/',
                '/preseed/pixmaps/',
                '/preseed/tools/',
                '/preseed/protools/',
                '/preseed/polkit/',
                '/preseed/conf/',
                '/preseed/py/',
                '/preseed/lightdm/',
                '/preseed/autostart/'
                )
    src_q = collections.deque(src_paths)
    des_q = collections.deque(des_paths)
    size_q = len(des_q)
    for size_length in range(size_q):
        source = src_q.popleft()
        des = des_q.popleft()
        logger.info(MSG_COPY+ HOME_FOLDER + source)
        shutil.copytree(HOME_FOLDER + source,
                        HOME_FOLDER + WPINSTALLER + des,
                        dirs_exist_ok = True
                        )
        logger.info(MSG_FIN + HOME_FOLDER + WPINSTALLER + des)


class ArchitectureFiles:
    """ 
        Copy all the needed files to CHROOT  Depending on the
        architecture it will, copy files as needed 
    """
    #another solution is necessary for the calamares files as they are not necessary in the server builds, the mini builds are not affected because the chroot is deleted during the binary phase.
    def __init__(self, sbase, sarch):

        logger.info("Copy Architecture")

        self.sbase = sbase
        self.sarch = sarch
        calamares_path = '/calamares_settings/'
        sources_path = '/sources/'
        src_paths = (#calamares_path + self.sbase + self.sarch +
                     #'/calamares/settings.conf',
                     #calamares_path + self.sbase + self.sarch +
                     #'/install-peppermint',
                     #calamares_path + self.sbase + self.sarch +
                     #'/sources-final',
                     #calamares_path + self.sbase + self.sarch +
                     #'/bootloader-config',
                     #calamares_path +
                     #'adddesktopicon/add-calamares-desktop-icon',
                     sources_path + self.sbase + self.sarch +
                     '/sources.list', 
                     #'/id_files/pep_id'
                      )
        des_paths = (#'/etc/calamares/settings.conf',
                     #'/usr/bin/install-peppermint',
                     #'/usr/sbin/sources-final',
                     #'/usr/sbin/bootloader-config',
                     #'/usr/bin/add-calamares-desktop-icon',
                     '/opt/pepconf/sources.list',
                     '/usr/share/peppermint/pep_id'
                      )
        # copy files to thier CHROOT Location
        src_q = collections.deque(src_paths)
        des_q = collections.deque(des_paths)
        size_q = len(src_q)
        for size_length in range(size_q):
            source = src_q.popleft()
            des = des_q.popleft()
            logger.info(MSG_COPY+ HOME_FOLDER + source)
            shutil.copy(HOME_FOLDER + source,
                        HOME_FOLDER + WPCHROOT + des
                        )
            logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des)


def set_symlinks():
    """
    Set the symliknks that are used for all builds.
    """

    logger.info("Copy Symlinks")

    pep_info = '/usr/share/python-apt/templates/Peppermint.info'
    pep_mirror = '/usr/share/python-apt/templates/Peppermint.mirrors'
    pep_csv = '/usr/share/distro-info/peppermint.csv'
    logger.info("Making   - " + HOME_FOLDER + WPCHROOT + pep_info)
    os.symlink('Debian.info', HOME_FOLDER + WPCHROOT + pep_info)
    logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + pep_info)
    logger.info("Making   - " + HOME_FOLDER + WPCHROOT + pep_mirror)
    os.symlink('Debian.mirrors', HOME_FOLDER + WPCHROOT + pep_mirror)
    logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + pep_mirror)
    logger.info("Making   - " + HOME_FOLDER + WPCHROOT + pep_csv)
    os.symlink('debian.csv', HOME_FOLDER + WPCHROOT + pep_csv)
    logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + pep_csv)


def shared_folders():
    """ 
        This function will get the files that are shared commonly amongst 
        all the builds, 
    """

    logger.info("Copy Shared folders")

    src_paths = ('/plymouth/lines',
                 '/application', 
                 '/font',
                 '/hooks/live', 
                 '/issue', 
                 '/issue',
                 '/polkit',
                 '/database',
                 '/user_config',
                 '/PepProPixMaps',
                 '/wallpaper',
                 '/menu/menus',
                 '/face',
                 '/neofetch/neofetch',
                 '/pmostools',
                 '/autostart',
                 '/pylibraries',
                 #'/calamares_settings/branding'
                 )
    des_paths =('/usr/share/plymouth/themes/lines',
                '/usr/share/applications', 
                '/usr/share/fonts/pepconf',
                '/usr/lib/live/config', 
                '/etc', 
                '/opt/pepconf',
                '/usr/share/polkit-1/actions',
                '/opt/pypep/dbpep',
                '/etc/live/config.conf.d', 
                '/usr/share/pixmaps',
                '/usr/share/backgrounds', 
                '/etc/skel/.config/menus',
                '/etc/skel/', 
                '/etc/skel/.config/neofetch',
                '/etc/skel/.local/share/pmostools',
                '/etc/skel/.config/autostart',
                '/usr/lib/python3/dist-packages',
                #'/etc/calamares/branding'
                )
    src_q = collections.deque(src_paths)
    des_q = collections.deque(des_paths)
    size_q = len(des_q)
    for size_length in range(size_q):
        source = src_q.popleft()
        des = des_q.popleft()
        logger.info(MSG_COPY+ HOME_FOLDER + source)
        shutil.copytree(HOME_FOLDER + source,
                        HOME_FOLDER + WPCHROOT + des,
                        dirs_exist_ok = True
                        )
        logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des)


def icons_themes():
    """ 
        This function will get the icons and themse that are 
        for all the builds 
    """

    logger.info("Copy icons and themes")

    src_paths =('/theme/Marwaita Dark Debian/',
                '/theme/Marwaita Dark Manjaro/',
                '/theme/Marwaita Dark Peppermint/',
                '/theme/Marwaita Debian/',
                '/theme/Marwaita Manjaro/',
                '/theme/Marwaita Peppermint/',
                '/theme/Marwaita-Xfwm/',
                '/theme/Marwaita-Xfwm-Alt/',
                '/theme/Marwaita-Xfwm-Color-Dark-Text/',
                '/theme/Marwaita-Xfwm-Color-Light-Text/',
                '/theme/Marwaita-Xfwm-Dark/',
                '/icons/Tela-circle-blue-dark/',
                '/icons/Tela-circle-green-dark/',
                '/icons/Tela-circle-red-dark/',
                '/icons/Tela-circle-blue/',
                '/icons/Tela-circle-green/',
                '/icons/Tela-circle-red/',
                '/icons/Tela-circle/'
                )
    des_paths = ('/usr/share/themes/Marwaita Dark Debian/',
                 '/usr/share/themes/Marwaita Dark Manjaro/',
                 '/usr/share/themes/Marwaita Dark Peppermint/',
                 '/usr/share/themes/Marwaita Debian/',
                 '/usr/share/themes/Marwaita Manjaro/',
                 '/usr/share/themes/Marwaita Peppermint/',
                 '/usr/share/themes/Marwaita-Xfwm/',
                 '/usr/share/themes/Marwaita-Xfwm-Alt/',
                 '/usr/share/themes/Marwaita-Xfwm-Color-Dark-Text/',
                 '/usr/share/themes/Marwaita-Xfwm-Color-Light-Text/',
                 '/usr/share/themes/Marwaita-Xfwm-Dark/',
                 '/usr/share/icons/Tela-circle-blue-dark/',
                 '/usr/share/icons/Tela-circle-green-dark/',
                 '/usr/share/icons/Tela-circle-red-dark/',
                 '/usr/share/icons/Tela-circle-blue/',
                 '/usr/share/icons/Tela-circle-green/',
                 '/usr/share/icons/Tela-circle-red/',
                 '/usr/share/icons/Tela-circle/'
                 )
    src_q = collections.deque(src_paths)
    des_q = collections.deque(des_paths)
    size_q = len(src_q)


    for size_length in range(size_q):
        source = src_q.popleft()
        des = des_q.popleft()
        logger.info(MSG_COPY+ HOME_FOLDER + source)
        shutil.copytree(HOME_FOLDER + source,
                        HOME_FOLDER + WPCHROOT + des,
                        dirs_exist_ok = True
                        )
        logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des)


def shared_files():
    """ 
        This silll copy all specific files that a used for all
        builds.
    """

    logger.info("Copy Shared Files")

    src_paths = ('/aliases/bash_aliases',
                 '/sources/peppermint.list',
                 '/PepProTools/xDaily',
                 '/PepProTools/hub',
                 '/PepProTools/welcome',
                 '/PepProTools/kumo',
                 '/lightdm/lightdm.conf',
                 '/lightdm/lightdm-gtk-greeter.conf',
                 '/plymouth/plymouthd.conf',
                 #'/packages/deb-multimedia-keyring_2016.8.1_all.deb',
#                 '/repo_public_key/trusted.gpg',

                 )
    des_paths = ('/etc/skel/.bash_aliases',
                 '/etc/apt/sources.list.d',
                 '/usr/local/bin/xDaily',
                 '/usr/local/bin/hub',
                 '/usr/local/bin/welcome',
                 '/usr/local/bin/kumo',
                 '/etc/lightdm/lightdm.conf',
                 '/etc/lightdm/lightdm-gtk-greeter.conf',
                 '/usr/share/plymouthd.conf',
                 #'/opt/pepconf/deb-multimedia-keyring_2016.8.1_all.deb',
                 #'/etc/apt/trusted.gpg.d/trusted.gpg',
                 )
    # copy files to thier CHROOT Location
    src_q = collections.deque(src_paths)
    des_q = collections.deque(des_paths)
    size_q = len(src_q)
    for size_length in range(size_q):
        source = src_q.popleft()
        des = des_q.popleft()
        logger.info(MSG_COPY+ HOME_FOLDER + source)
        shutil.copy(HOME_FOLDER + source,
                    HOME_FOLDER + WPCHROOT + des
                    )
        logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des)


def shared_server_files():
    """ 
        This silll copy all specific files that a used for the server
        builds.
    """

    logger.info("Copy Shared Files")

    src_paths = ('/server/firewall/public.xml',
                 )
    des_paths = ('/etc/firewalld/zones',
                 )
    # copy files to thier CHROOT Location
    src_q = collections.deque(src_paths)
    des_q = collections.deque(des_paths)
    size_q = len(src_q)
    for size_length in range(size_q):
        source = src_q.popleft()
        des = des_q.popleft()
        logger.info(MSG_COPY+ HOME_FOLDER + source)
        shutil.copy(HOME_FOLDER + source,
                    HOME_FOLDER + WPCHROOT + des
                    )
        logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des)

def boostrap_shared():
    """ 
    Copy specific folders in the boostrap location
    """

    logger.info("Copy Shared BootStrap")

    src_paths = ('/issue',)
    des_paths = ('/etc',)
    src_q = collections.deque(src_paths)
    des_q = collections.deque(des_paths)
    size_q = len(src_q)
    for size_length in range(size_q):
        source = src_q.popleft()
        des = des_q.popleft()
        logger.info(MSG_COPY+ HOME_FOLDER + source)
        shutil.copytree(HOME_FOLDER + source,
                        HOME_FOLDER + BOOTSTRAP + des,
                       dirs_exist_ok = True
                       )
        logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des)


def xfce_configs():
    """
    Copy the xfce files. 
    """

    logger.info("Copy xfce4 configs")

    src_xfce = '/xfce/xfce4'
    des_xfce = '/etc/skel/.config/xfce4'
    logger.info(MSG_COPY + HOME_FOLDER + src_xfce)
    shutil.copytree(HOME_FOLDER + src_xfce,
                    HOME_FOLDER + WPCHROOT + des_xfce,
                    dirs_exist_ok = True
                    )
    logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des_xfce)
    src_thunar = '/xfce/Thunar'
    des_thunar = '/etc/skel/.config/Thunar'
    logger.info(MSG_COPY+ HOME_FOLDER + src_thunar)
    shutil.copytree(HOME_FOLDER + src_thunar,
                    HOME_FOLDER + WPCHROOT + des_thunar,
                    dirs_exist_ok = True
                    )
    logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des_thunar)


def gnome_flahsbak_configs():
    """
     Copy the gnome flashback files
    """

    logger.info("Copy Gnome Flashback configs")
    src_gnomef = '/gnome-flashback'
    des_gnomef = '/etc/skel/'
    logger.info("INFO: Copying  - " + HOME_FOLDER + src_gnomef)
    shutil.copytree(HOME_FOLDER + src_gnomef,
                    HOME_FOLDER + WPCHROOT + des_gnomef,
                    dirs_exist_ok = True
                    )
    logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des_gnomef)


def open_box_configs():
    """
     Copy the openbox files
    """

    logger.info("Copy openbox configs")
    src_ob = '/openbox'
    des_ob = '/etc/skel/'
    logger.info("INFO: Copying  - " + HOME_FOLDER + src_ob)
    shutil.copytree(HOME_FOLDER + src_ob,
                    HOME_FOLDER + WPCHROOT + des_ob,
                    dirs_exist_ok = True
                    )
    logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des_ob)


def loaded_configs():
    """
     Copy the loaded xfce files
    """#

    logger.info("Copy loaded xfce configs")
    src_loaded = '/loaded/xfce'
    des_loaded = '/etc/skel/.config/'
    logger.info("INFO: Copying  - " + HOME_FOLDER + src_loaded)
    shutil.copytree(HOME_FOLDER + src_loaded,
                    HOME_FOLDER + WPCHROOT + des_loaded,
                    dirs_exist_ok = True
                    )
    logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des_loaded)


def loaded_folders():
    """ 
        This function will get the files that are used by the loaded builds, 
    """

    logger.info("Copy loaded folders")

    src_paths = ('/loaded/application',
                 '/loaded/wallpaper'
                 )
    des_paths =('/usr/share/applications', 
                '/usr/share/backgrounds'
                 )
    src_q = collections.deque(src_paths)
    des_q = collections.deque(des_paths)
    size_q = len(des_q)
    for size_length in range(size_q):
        source = src_q.popleft()
        des = des_q.popleft()
        logger.info(MSG_COPY+ HOME_FOLDER + source)
        shutil.copytree(HOME_FOLDER + source,
                        HOME_FOLDER + WPCHROOT + des,
                        dirs_exist_ok = True
                        )
        logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des)

def server_configs():
    """
     Copy the server files
    """#

    logger.info("Copy server configs")
    src_server = '/server/configs'
    des_server = '/etc/skel/.config/'
    logger.info("INFO: Copying  - " + HOME_FOLDER + src_server)
    shutil.copytree(HOME_FOLDER + src_server,
                    HOME_FOLDER + WPCHROOT + des_server,
                    dirs_exist_ok = True
                    )
    logger.info(MSG_FIN + HOME_FOLDER + WPCHROOT + des_server)