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"
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 
    """
    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 ArchitectureFiles:
    """ 
        Copy all the needed files to CHROOT  Depending on the
        architecture it will, copy files as needed 
    """
    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 fusato_configs():
    """ 
    Copy specific folders in the root of fusato configs
    """

    logger.info("Copy Fusato Configs")

    src_paths = ('/hooks/normal',)
    des_paths = ('/hooks/normal',)
    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 + FUSATOCONFIG + des,
                        dirs_exist_ok = True
                        )
        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-hooks/normal', 
                 '/loaded-wallpaper',
                 #'/calamares_settings/branding'
                 )
    des_paths =('/usr/share/applications', 
                '/hooks/normal', 
                '/usr/share/backgrounds', 
                #'/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)