bubbles/python_modules/build_iso.py

"""
* Author: "PeppermintOS Team(peppermintosteam@proton.me)
*
* License: SPDX-License-Identifier: GPL-3.0-or-later
*
* Build the ISOs for the the system
"""
import os
from pathlib import Path
import argparse
import collections
import logging
import conf
import infra
import inflate_bubble
import finish_cleanup

# Set the home path used regardless the user logged in
BSTRING_ISO_CONFIGS = '~/bubbles/iso_configs'
HOME_FOLDER = str(Path(BSTRING_ISO_CONFIGS).expanduser())
FUSATO_ROOT = '/fusato'
WPCHROOT = '/fusato/config/includes.chroot'

# Set the architecture variables
deb_base = 'deb'
dev_base = 'dev'
arch_64 = '_64'
arch_32 = '_32'
arch_arm = '_arm'

# Set up the logging format
logger = logging.getLogger()
handler = logging.StreamHandler()
formatter = logging.Formatter(
        '%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)

# Common Logging Messages
CFG_TREE_READY = "Config tree ready!"
CFG_READY = "Configs in place start the ISO build process"
START_LIVEBUILD = "Start Live-Build Process"
BUILD_COMPLETED = "ISO build has completed successfully"
BUILD_COMPLETED = "ISO is ready for usage."


class BuildXfce:
    """
    Determine what base to use and then build the ISO
    """
    def __init__(self, sbase, sarch):
        self.sbase = sbase
        self.sarch = sarch
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Determine what base to build
        if sbase == deb_base:
            # Run the Debian Build
            self.debian_build()
        elif sbase == dev_base:
            self.devuan_build()
        else:
            print("No base has been found")


    def build_deb_64(self):
        """ Builds the 64bit ISO XFCE"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        logger.info("Building a Debian based 64 bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEB64
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the XFCE stuff
        cmd_list_64 = collections.deque(conf.build64_xfce_build)
        list_size_64 = len(cmd_list_64)
        for _ in range(list_size_64):
            i = cmd_list_64.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(deb_base, deb_base)
        infra.BinaryFolders(deb_base, deb_base)
        infra.ArchitectureFiles(deb_base, deb_base)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEB64
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_xfce(deb_base, "64")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_debian_xfce_based()
        finish_cleanup.kill_old_iso()
        logger.info(BUILD_COMPLETED)


    def build_deb_32(self):
        """ Builds the 32bit ISO XFCE"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        logger.info("Building a Debian based 32 bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEB32
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the XFCE stuff
        cmd_list_32 = collections.deque(conf.build32_xfce_build)
        list_size_32 = len(cmd_list_32)
        for _ in range(list_size_32):
            i = cmd_list_32.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(deb_base, arch_32)
        infra.BinaryFolders(deb_base, arch_32)
        infra.ArchitectureFiles(deb_base, arch_32)
        infra.Archive(deb_base, arch_32)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEB32
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_xfce(deb_base, "32")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_debian_xfce_based()
        finish_cleanup.kill_old_iso()
        logger.info(BUILD_COMPLETED)


    def build_deb_arm(self):
        """ Builds the arm ISO XFCE"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        logger.info("Building a Debian based arm bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEBARM
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the XFCE stuff
        cmd_list_arm = collections.deque(conf.buildarm_xfce_build)
        list_size_arm = len(cmd_list_arm)
        for _ in range(list_size_arm):
            i = cmd_list_arm.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(deb_base, arch_arm)
        infra.BinaryFolders(deb_base, arch_arm)
        infra.ArchitectureFiles(deb_base, arch_arm)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEBARM
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_xfce(deb_base, "arm")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_debian_xfce_based()
        finish_cleanup.kill_old_iso()
        logger.info(BUILD_COMPLETED)


    def debian_build(self):
        """
        Used to build the Debian base XFCE ISO
        """
        if self.sarch == arch_64:
            self.build_deb_64()
        elif self.sarch == arch_32:
            self.build_deb_32()
        elif self.sarch == arch_arm:
            self.build_deb_arm()
        else:
            logger.warning("No active build specified!")


    def build_dev_64(self):
        """ Builds the 64bit ISO XFCE"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        logger.info("Building a devuan based 64 bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEV64
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the XFCE stuff
        cmd_list_64 = collections.deque(conf.build64_xfce_build)
        list_size_64 = len(cmd_list_64)
        for _ in range(list_size_64):
            i = cmd_list_64.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(dev_base, deb_base)
        infra.BinaryFolders(dev_base, deb_base)
        infra.ArchitectureFiles(dev_base, deb_base)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEV64
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_xfce(dev_base,"64")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_devuan_xfce_based()
        finish_cleanup.kill_old_iso()
        #'finish_cleanup.copy_iso_file_prod_deb64',
        logger.info(BUILD_COMPLETED)


    def build_dev_32(self):
        """ Builds the 32bit ISO XFCE"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        logger.info("Building a devuan based 32 bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEV32
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the XFCE stuff
        cmd_list_32 = collections.deque(conf.build32_xfce_build)
        list_size_32 = len(cmd_list_32)
        for _ in range(list_size_32):
            i = cmd_list_32.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(dev_base, arch_32)
        infra.BinaryFolders(dev_base, arch_32)
        infra.ArchitectureFiles(dev_base, arch_32)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEV32
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_xfce(dev_base,"32")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_devuan_xfce_based()
        finish_cleanup.kill_old_iso()
        #'finish_cleanup.copy_iso_file_prod_deb32',
        logger.info(BUILD_COMPLETED)


    def build_dev_arm(self):
        """ Builds the arm ISO XFCE"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        print("INFO: Building a devuan based arm bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEVARM
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the XFCE stuff
        cmd_list_arm = collections.deque(conf.buildarm_xfce_build)
        list_size_arm = len(cmd_list_arm)
        for _ in range(list_size_arm):
            i = cmd_list_arm.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(dev_base, arch_arm)
        infra.BinaryFolders(dev_base, arch_arm)
        infra.ArchitectureFiles(dev_base, arch_arm)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEVARM
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_xfce(dev_base,"arm")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_devuan_xfce_based()
        finish_cleanup.kill_old_iso()
        #'finish_cleanup.copy_iso_file_prod_DEBARM',
        logger.info(BUILD_COMPLETED)


    def devuan_build(self):
        """
        Used to build the devuan base XFCE ISO
        """
        if self.sarch == "_64":
            self.build_dev_64()
        elif self.sarch == "_32":
            self.build_dev_32()
        elif self.sarch == "_arm":
            self.build_dev_arm()
        else:
            print("WARNING: No active build specified")


class BuildGflashback:
    """
    Determine what base to use and then build the ISO
    """
    def __init__(self, sbase, sarch):
        self.sbase = sbase
        self.sarch = sarch
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Determine what base to build
        if sbase == deb_base:
            # Run the Debian Build
            self.debian_build()
        elif sbase == dev_base:
            self.devuan_build()
        else:
            print("No base has been found")


    def build_deb_64(self):
        """ Builds the 64bit ISO GNOME FlashBack"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        logger.info("Building a Debian based 64 bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEB64
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the GNOME FlashBack stuff
        cmd_list_64 = collections.deque(conf.build64_gfb_build)
        list_size_64 = len(cmd_list_64)
        for _ in range(list_size_64):
            i = cmd_list_64.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(deb_base, deb_base)
        infra.BinaryFolders(deb_base, deb_base)
        infra.ArchitectureFiles(deb_base, deb_base)
        infra.Archive(deb_base, deb_base)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEB64
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_gnomeflashback(deb_base,"64")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_debian_gfb_based()
        finish_cleanup.kill_old_iso()
        logger.info(BUILD_COMPLETED)


    def build_deb_32(self):
        """ Builds the 32bit ISO GNOME FlashBack"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        print("INFO: Building a Debian based 32 bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEB32
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the GNOME FlashBack stuff
        cmd_list_32 = collections.deque(conf.build32_gfb_build)
        list_size_32 = len(cmd_list_32)
        for _ in range(list_size_32):
            i = cmd_list_32.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(deb_base, arch_32)
        infra.BinaryFolders(deb_base, arch_32)
        infra.ArchitectureFiles(deb_base, arch_32)
        infra.Archive(deb_base, arch_32)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEB32
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_gnomeflashback(deb_base,"32")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_debian_gfb_based()
        finish_cleanup.kill_old_iso()
        logger.info(BUILD_COMPLETED)


    def build_deb_arm(self):
        """ Builds the arm ISO GNOME FlashBack"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        print("INFO: Building a Debian based arm bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEBARM
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the GNOME FlashBack stuff
        cmd_list_arm = collections.deque(conf.buildarm_gfb_build)
        list_size_arm = len(cmd_list_arm)
        for _ in range(list_size_arm):
            i = cmd_list_arm.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(deb_base, arch_arm)
        infra.BinaryFolders(deb_base, arch_arm)
        infra.ArchitectureFiles(deb_base, arch_arm)
        infra.Archive(deb_base, arch_arm)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEBARM
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_gnomeflashback(deb_base,"arm")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_debian_gfb_based()
        finish_cleanup.kill_old_iso()
        logger.info(BUILD_COMPLETED)


    def debian_build(self):
        """
        Used to build the Debian base GNOME FlashBack ISO
        """
        if self.sarch == arch_64:
            self.build_deb_64()
        elif self.sarch == arch_32:
            self.build_deb_32()
        elif self.sarch == arch_arm:
            self.build_deb_arm()
        else:
            print("WARNING: No active build specified")


    def build_dev_64(self):
        """ Builds the 64bit ISO GNOME FlashBack"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        print("INFO: Building a devuan based 64 bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEV64
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the GNOME FlashBack stuff
        cmd_list_64 = collections.deque(conf.build64_gfb_build)
        list_size_64 = len(cmd_list_64)
        for _ in range(list_size_64):
            i = cmd_list_64.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(dev_base, deb_base)
        infra.BinaryFolders(dev_base, deb_base)
        infra.ArchitectureFiles(dev_base, deb_base)
        infra.Archive(dev_base, deb_base)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEV64
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_gnomeflashback(dev_base,"64")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_devuan_gfb_based()
        finish_cleanup.kill_old_iso()
        #'finish_cleanup.copy_iso_file_prod_deb64',
        logger.info(BUILD_COMPLETED)


    def build_dev_32(self):
        """ Builds the 32bit ISO GNOME FlashBack"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        print("INFO: Building a devuan based 32 bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEV32
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the GNOME FlashBack stuff
        cmd_list_32 = collections.deque(conf.build32_gfb_build)
        list_size_32 = len(cmd_list_32)
        for _ in range(list_size_32):
            i = cmd_list_32.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(dev_base, arch_32)
        infra.BinaryFolders(dev_base, arch_32)
        infra.ArchitectureFiles(dev_base, arch_32)
        infra.Archive(dev_base, arch_32)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEV32
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_gnomeflashback(dev_base,"32")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_devuan_gfb_based()
        finish_cleanup.kill_old_iso()
        #'finish_cleanup.copy_iso_file_prod_deb32',
        logger.info(BUILD_COMPLETED)


    def build_dev_arm(self):
        """ Builds the arm ISO GNOME FlashBack"""
        current_working_directory = os.getcwd()
        dir_current = "Current working directory" + current_working_directory
        print("INFO: Building a devuan based arm bit ISO")
        logger.info(dir_current)
        # Set the config tree
        lbsetup = conf.LBSET_DEVARM
        os.system(lbsetup)
        logger.info(CFG_TREE_READY)
        # Start with the GNOME FlashBack stuff
        cmd_list_arm = collections.deque(conf.buildarm_gfb_build)
        list_size_arm = len(cmd_list_arm)
        for _ in range(list_size_arm):
            i = cmd_list_arm.popleft()
            execute = i + '()'
            exec(execute)
        # Run the specific classes
        infra.ChrootFolders(dev_base, arch_arm)
        infra.BinaryFolders(dev_base, arch_arm)
        infra.ArchitectureFiles(dev_base, arch_arm)
        infra.Archive(dev_base, arch_arm)
        # Run the Build
        logger.info(CFG_READY)
        logger.info(START_LIVEBUILD)
        logger.info(dir_current)
        lbsetup = conf.LBSET_DEVARM
        os.system(lbsetup)
        run_cmd = 'sudo lb build'
        current_working_directory = os.getcwd()
        os.chdir(HOME_FOLDER + FUSATO_ROOT)
        # Set the build inidcator
        inflate_bubble.make_bld_gnomeflashback(dev_base, "arm")
        logger.info(dir_current)
        os.system(run_cmd)
        logger.info(BUILD_COMPLETED)
        logger.info(dir_current)
        finish_cleanup.make_check_sum()
        finish_cleanup.copy_devuan_gfb_based()
        finish_cleanup.kill_old_iso()
        #'finish_cleanup.copy_iso_file_prod_DEBARM',
        logger.info(BUILD_COMPLETED)


    def devuan_build(self):
        """
        Used to build the devuan base GNOME FlashBack ISO
        """
        if self.sarch == arch_64:
            self.build_dev_64()
        elif self.sarch == arch_32:
            self.build_dev_32()
        elif self.sarch == arch_arm:
            self.build_dev_arm()
        else:
            print("WARNING: No active build specified")


def readybuild():
    """" Make Ready the bld structure If fusato exists remove it.
         and recreate it, otherwise just make a new folder named
         fusato.
    """
    logger.info("Making ready the fusato build directory")
    os.chdir(HOME_FOLDER)
    if os.path.exists('fusato'):
        rm_cmd = "sudo rm -r -f fusato"
        os.system(rm_cmd)
        os.makedirs('fusato')
    else:
        os.makedirs('fusato')


class Decsions:
    """
    Aguments used to tell the application what to build
    """
    def __init__(self):
        # Set up the terminal arguments
        self.argument_parser = argparse.ArgumentParser()
        self.argument_parser.add_argument("set",
                                          help="set what build to start",
                                          type=str
                                          )
        self.argument_parser.add_argument("e",
                                          help="identify the desktop"
                                               " environment for example"
                                               " e-xfce",
                                          type=str
                                          )
        self.argument_parser.add_argument("b",
                                          help="identify the ISO to"
                                               "build for example"
                                               " b-deb64",
                                          type=str
                                          )
        self.arguments = self.argument_parser.parse_args()
        # Then determine what desktop build to look for
        if self.arguments.e == 'e-gnomefb':
            self.dgnomefb()
        elif self.arguments.e == 'e-xfce':
            self.dxfce()
        elif self.arguments.e == 'e-openbox':
            self.dopenbox()

    def dxfce(self):
        """ Arguments for the XFCE """
        if self.arguments.e == 'e-xfce':
            if self.arguments.b == 'b-deb64':
                readybuild()
                BuildXfce(deb_base, deb_base)
            elif self.arguments.b == 'b-deb32':
                readybuild()
                BuildXfce(deb_base, arch_32)
            elif self.arguments.b == 'b-dev64':
                readybuild()
                BuildXfce(dev_base, deb_base)
            elif self.arguments.b == 'b-dev32':
                readybuild()
                BuildXfce(dev_base, arch_32)
            elif self.arguments.b == 'b-debarm':
                readybuild()
                BuildXfce(deb_base, arch_arm)
            elif self.arguments.b == 'b-devarm':
                readybuild()
                BuildXfce(dev_base, arch_arm)
            else:
                logger.critical("You have not specified a build to process!")

    def dgnomefb(self):
        """ Arguments for the gnomefb """
        if self.arguments.e == 'e-gnomefb':
            if self.arguments.b == 'b-deb64':
                readybuild()
                BuildGflashback(deb_base, deb_base)
            elif self.arguments.b == 'b-deb32':
                readybuild()
                BuildGflashback(deb_base, arch_32)
            elif self.arguments.b == 'b-debarm':
                readybuild()
                BuildGflashback(deb_base, arch_arm)
            elif self.arguments.b == 'b-dev32':
                readybuild()
                BuildGflashback(dev_base, arch_32)
            elif self.arguments.b == 'b-dev64':
                readybuild()
                BuildGflashback(dev_base, deb_base)
            elif self.arguments.b == 'b-devarm':
                readybuild()
                BuildGflashback(dev_base, arch_arm)
            else:
                logger.critical("You have not specified a build to process!")

    def dopenbox(self):
        """ Arguments for the openbox """
        if self.arguments.e == 'e-openbox':
            if self.arguments.b == 'b-deb64':
                readybuild()
                print('run openbox builds deb64')
            elif self.arguments.b == 'b-deb32':
                readybuild()
                print('run openbox builds deb32')
            elif self.arguments.b == 'b-dev64':
                readybuild()
                print('run openbox builds dev64')
            elif self.arguments.b == 'b-dev32':
                readybuild()
                print('run openbox builds dev32')
            elif self.arguments.b == 'b-debarm':
                readybuild()
                print('run openbox builds debarm')
            elif self.arguments.b == 'b-devarm':
                readybuild()
                print('run openbox builds devarm')
            else:
                print('You have not specified a valid '
                      'build architecture!!')
        else:
            logger.critical("You have not specified a valid "
                            "desktop environment!!")


Decsions()