@@ -163,6 +163,7 @@ packages: check-docker-py check-tools photon-stage $(PHOTON_PUBLISH_XRPMS) $(PHO

 		$(PUBLISH_BUILD_DEPENDENCIES) \

 		$(PACKAGE_WEIGHTS) \

 		--threads ${THREADS}

+	$(PHOTON_REPO_TOOL) $(PHOTON_RPMS_DIR)

 packages-docker: check-docker-py check-docker-service check-tools photon-stage $(PHOTON_PUBLISH_XRPMS) $(PHOTON_PUBLISH_RPMS) $(PHOTON_SOURCES) $(CONTAIN) generate-dep-lists

 	@echo "Building all RPMS..."

@@ -438,6 +439,7 @@ packages-cached:

 	$(RM) -f $(PHOTON_RPMS_DIR_ARCH)/* && \

 	$(CP) -f $(PHOTON_CACHE_PATH)/RPMS/noarch/* $(PHOTON_RPMS_DIR_NOARCH)/ && \

 	$(CP) -f $(PHOTON_CACHE_PATH)/RPMS/$(ARCH)/* $(PHOTON_RPMS_DIR_ARCH)/

+	$(PHOTON_REPO_TOOL) $(PHOTON_RPMS_DIR)

 sources:

 	@$(MKDIR) -p $(PHOTON_SRCS_DIR)

@@ -1,6 +1,9 @@

 # pylint: disable=invalid-name,missing-docstring

 import subprocess

 import os

+import crypt

+import string

+import random

 class CommandUtils(object):

     def __init__(self, logger):

@@ -16,3 +19,21 @@ class CommandUtils(object):

             self.logger.debug(err.decode())

         return retval

+    @staticmethod

+    def is_vmware_virtualization():

+        """Detect vmware vm"""

+        process = subprocess.Popen(['systemd-detect-virt'], stdout=subprocess.PIPE)

+        out, err = process.communicate()

+        if err is not None and err != 0:

+            return False

+        return out.decode() == 'vmware\n'

+

+    @staticmethod

+    def generate_password_hash(password):

+        """Generate hash for the password"""

+        shadow_password = crypt.crypt(

+            password, "$6$" + "".join(

+                [random.choice(

+                    string.ascii_letters + string.digits) for _ in range(16)]))

+        return shadow_password

+

@@ -12,6 +12,7 @@ import sys

 import glob

 import re

 import modules.commons

+import random

 from logger import Logger

 from commandutils import CommandUtils

 from jsonwrapper import JsonWrapper

@@ -23,34 +24,51 @@ class Installer(object):

     """

     Photon installer

     """

+

+    # List of allowed keys in kickstart config file.

+    # Please keep ks_config.txt file updated.

+    known_keys = {

+        'additional_packages',

+        'autopartition',

+        'bootmode',

+        'disk',

+        'eject_cdrom',

+        'hostname',

+        'install_linux_esx',

+        'packages',

+        'packagelist_file',

+        'partition_type',

+        'partitions',

+        'password',

+        'postinstall',

+        'public_key',

+        'setup_grub_script',

+        'shadow_password',

+        'type'

+    }

+

     mount_command = os.path.dirname(__file__)+"/mk-mount-disk.sh"

+    prepare_command = os.path.dirname(__file__)+"/mk-prepare-system.sh"

     finalize_command = "./mk-finalize-system.sh"

     chroot_command = os.path.dirname(__file__)+"/mk-run-chroot.sh"

     unmount_disk_command = os.path.dirname(__file__)+"/mk-unmount-disk.sh"

     default_partitions = [{"mountpoint": "/", "size": 0, "filesystem": "ext4"}]

-    def __init__(self, install_config, maxy=0, maxx=0, iso_installer=False,

+    def __init__(self, working_directory="/mnt/photon-root", maxy=0, maxx=0, iso_installer=False,

                  rpm_path=os.path.dirname(__file__)+"/../stage/RPMS", log_path=os.path.dirname(__file__)+"/../stage/LOGS", log_level="info"):

         self.exiting = False

-        self.install_config = install_config

-        self.install_config['iso_installer'] = iso_installer

+        self.interactive = False

+        self.install_config = None

+        self.iso_installer = iso_installer

         self.rpm_path = rpm_path

         self.logger = Logger.get_logger(log_path, log_level, not iso_installer)

         self.cmd = CommandUtils(self.logger)

+        self.working_directory = working_directory

-        if 'working_directory' in self.install_config:

-            self.working_directory = self.install_config['working_directory']

-        else:

-            self.working_directory = "/mnt/photon-root"

-

-        if os.path.exists(self.working_directory) and os.path.isdir(self.working_directory):

+        if os.path.exists(self.working_directory) and os.path.isdir(self.working_directory) and working_directory == '/mnt/photon-root':

             shutil.rmtree(self.working_directory)

-        os.mkdir(self.working_directory)

-

-        if 'prepare_script' in self.install_config:

-            self.prepare_command = self.install_config['prepare_script']

-        else:

-            self.prepare_command = os.path.dirname(__file__)+"/mk-prepare-system.sh"

+        if not os.path.exists(self.working_directory):

+            os.mkdir(self.working_directory)

         self.photon_root = self.working_directory + "/photon-chroot"

         self.installer_path = os.path.dirname(os.path.abspath(__file__))

@@ -60,13 +78,13 @@ class Installer(object):

         # used by tdnf.conf as cachedir=, tdnf will append the rest

         self.rpm_cache_dir_short = self.photon_root + '/cache/tdnf'

-        if 'setup_grub_script' in self.install_config:

-            self.setup_grub_command = self.install_config['setup_grub_script']

-        else:

-            self.setup_grub_command = os.path.dirname(__file__)+"/mk-setup-grub.sh"

+        self.setup_grub_command = os.path.dirname(__file__)+"/mk-setup-grub.sh"

+

         self.rpms_tobeinstalled = None

-        if self.install_config['iso_installer']:

+        if iso_installer:

+            self.maxy = maxy

+            self.maxx = maxx

             #initializing windows

             height = 10

             width = 75

@@ -83,11 +101,102 @@ class Installer(object):

         signal.signal(signal.SIGINT, self.exit_gracefully)

-    def install(self):

+    """

+    create, append and validate configuration date - install_config

+    """

+    def configure(self, install_config, ui_config = None):

+        # run UI configurator iff install_config param is None

+        if not install_config and ui_config:

+            from iso_config import IsoConfig

+            self.interactive = True

+            config = IsoConfig(self.maxy, self.maxx)

+            install_config = config.configure(ui_config)

+

+        self._add_defaults(install_config)

+

+        issue = self._check_install_config(install_config)

+        if issue:

+            self.logger.error(issue)

+            raise Exception(issue)

+

+        self.install_config = install_config

+

+

+    def execute(self):

+        if 'setup_grub_script' in self.install_config:

+            self.setup_grub_command = self.install_config['setup_grub_script']

+

+        if self.install_config.get('type', '') == "ostree_host":

+            ostree = OstreeInstaller(self.install_config, self.maxy, self.maxx, self.interactive,

+                              self.iso_installer, self.rpm_path, self.log_path, self.log_level)

+            return ostree.install()

+

+        return self._install()

+

+    def _add_defaults(self, install_config):

+        """

+        Add default install_config settings if not specified

+        """

+        # extend 'packages' by 'packagelist_file' and 'additional_packages'

+        packages = []

+        if 'packagelist_file' in install_config:

+            plf = install_config['packagelist_file']

+            if not plf.startswith('/'):

+                plf = os.path.join(os.path.dirname(__file__), plf)

+            json_wrapper_package_list = JsonWrapper(plf)

+            package_list_json = json_wrapper_package_list.read()

+            packages.extend(package_list_json["packages"])

+

+        if 'additional_packages' in install_config:

+            packages.extend(install_config['additional_packages'])

+

+        if 'packages' in install_config:

+            install_config['packages'] = list(set(packages + install_config['packages']))

+        else:

+            install_config['packages'] = packages

+

+        # 'bootmode' mode

+        if 'bootmode' not in install_config:

+            arch = subprocess.check_output(['uname', '-m'], universal_newlines=True)

+            if "x86_64" in arch:

+                install_config['bootmode'] = 'dualboot'

+            else:

+                install_config['bootmode'] = 'efi'

+

+        # define 'hostname' as 'photon-<RANDOM STRING>'

+        if "hostname" not in install_config or install_config['hostname'] == "":

+            install_config['hostname'] = 'photon-%12x' % random.randrange(16**12)

+

+        # Set crypted password if needed

+        if 'shadow_password' not in install_config:

+            if 'password' in install_config:

+                if install_config['password']['crypted']:

+                    install_config['shadow_password'] = install_config['password']['text']

+                else:

+                    install_config['shadow_password'] = CommandUtils.generate_password_hash(install_config['password']['text'])

+            else:

+                install_config['shadow_password'] = '*'

+

+    def _check_install_config(self, install_config):

+        """

+        Sanity check of install_config before its execution.

+        Return error string or None

+        """

+

+        unknown_keys = install_config.keys() - Installer.known_keys

+        if len(unknown_keys) > 0:

+            return "Unknown install_config keys: " + ", ".join(unknown_keys)

+

+        if not 'disk' in install_config:

+            return "No disk configured"

+

+        return None

+

+    def _install(self):

         """

         Install photon system and handle exception

         """

-        if self.install_config['iso_installer']:

+        if self.iso_installer:

             self.window.show_window()

             self.progress_bar.initialize('Initializing installation...')

             self.progress_bar.show()

@@ -97,7 +206,7 @@ class Installer(object):

         except Exception as inst:

             self.logger.exception(repr(inst))

             self.exit_gracefully()

-            if not self.install_config['iso_installer']:

+            if not self.iso_installer:

                 raise

     def _unsafe_install(self):

@@ -127,7 +236,7 @@ class Installer(object):

         del frame1

         if not self.exiting:

             self.exiting = True

-            if self.install_config['iso_installer']:

+            if self.iso_installer:

                 self.progress_bar.hide()

                 self.window.addstr(0, 0, 'Oops, Installer got interrupted.\n\n' +

                                    'Press any key to get to the bash...')

@@ -147,6 +256,8 @@ class Installer(object):

         if retval != 0:

             self.logger.error("Failed to unmount disks")

+        shutil.rmtree(self.photon_root)

+

         # Uninitialize device paritions mapping

         disk = self.install_config['disk']

         if 'loop' in disk:

@@ -156,12 +267,12 @@ class Installer(object):

                 return None

         # Congratulation screen

-        if self.install_config['iso_installer'] and not self.exiting:

+        if self.iso_installer and not self.exiting:

             self.progress_bar.hide()

             self.window.addstr(0, 0, 'Congratulations, Photon has been installed in {0} secs.\n\n'

                                'Press any key to continue to boot...'

                                .format(self.progress_bar.time_elapsed))

-            if 'ui_install' in self.install_config:

+            if self.interactive:

                 self.window.content_window().getch()

             self._eject_cdrom()

@@ -275,11 +386,11 @@ class Installer(object):

             self.logger.info("Failed to setup the disk for installation")

             self.exit_gracefully()

-        if self.install_config['iso_installer']:

+        if self.iso_installer:

             self.progress_bar.update_message('Initializing system...')

         self._bind_installer()

         self._bind_repo_dir()

-        retval = self.cmd.run([self.prepare_command, '-w', self.photon_root,

+        retval = self.cmd.run([Installer.prepare_command, '-w', self.photon_root,

                                self.working_directory, self.rpm_cache_dir])

         if retval != 0:

             self.logger.info("Failed to bind the installer and repo needed by tdnf")

@@ -289,7 +400,7 @@ class Installer(object):

         """

         Finalize the system after the installation

         """

-        if self.install_config['iso_installer']:

+        if self.iso_installer:

             self.progress_bar.show_loading('Finalizing installation')

         #Setup the disk

         retval = self.cmd.run([Installer.chroot_command, '-w', self.photon_root,

@@ -304,6 +415,8 @@ class Installer(object):

         retval = self.cmd.run(['rm', '-rf', os.path.join(self.photon_root, "cache")])

         if retval != 0:

             self.logger.error("Fail to remove the cache")

+        os.remove(self.tdnf_conf_path)

+        os.remove(self.tdnf_repo_path)

     def _post_install(self):

         # install grub

@@ -413,7 +526,7 @@ class Installer(object):

         # run in shell to do not throw exception if tdnf not found

         process = subprocess.Popen(tdnf_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

-        if self.install_config['iso_installer']:

+        if self.iso_installer:

             while True:

                 output = process.stdout.readline().decode()

                 if output == '':

@@ -475,10 +588,7 @@ class Installer(object):

         """

         Eject the cdrom on request

         """

-        eject_cdrom = True

-        if 'eject_cdrom' in self.install_config and not self.install_config['eject_cdrom']:

-            eject_cdrom = False

-        if eject_cdrom:

+        if self.install_config.get('eject_cdrom', True):

             self.cmd.run(['eject', '-r'])

     def _enable_network_in_chroot(self):

@@ -519,7 +629,7 @@ class Installer(object):

         Partition the disk

         """

-        if self.install_config['iso_installer']:

+        if self.iso_installer:

             self.progress_bar.update_message('Partitioning...')

         if 'partitions' not in self.install_config:

deleted file mode 100755

@@ -1,31 +0,0 @@

-#

-#

-#    Author: Touseef Liaqat <tliaqat@vmware.com>

-

-from installer import Installer

-from ostreeinstaller import OstreeInstaller

-

-class InstallerContainer(object):

-    def __init__(self, install_config, maxy=0, maxx=0,

-                 iso_installer=False, rpm_path="../stage/RPMS",

-                 log_path="../stage/LOGS", log_level="info"):

-

-        self.install_config = install_config

-        self.maxy = maxy

-        self.maxx = maxx

-        self.iso_installer = iso_installer

-        self.rpm_path = rpm_path

-        self.log_path = log_path

-        self.log_level = log_level

-

-    def install(self):

-        installer = None

-

-        if self.install_config.get('type', '') == "ostree_host":

-            installer = OstreeInstaller(self.install_config, self.maxy, self.maxx,

-                              self.iso_installer, self.rpm_path, self.log_path, self.log_level)

-        else:

-            installer = Installer(self.install_config, self.maxy, self.maxx,

-                              self.iso_installer, self.rpm_path, self.log_path, self.log_level)

-

-        return installer.install()

@@ -3,10 +3,11 @@

 #

 #    Author: Mahmoud Bassiouny <mbassiouny@vmware.com>

-from argparse import ArgumentParser

+import shlex

 import curses

-from installercontainer import InstallerContainer

-from iso_config import IsoConfig

+from argparse import ArgumentParser

+from installer import Installer

+from commandutils import CommandUtils

 class IsoInstaller(object):

     def __init__(self, stdscreen, options_file, rpms_path):

@@ -23,19 +24,124 @@ class IsoInstaller(object):

         self.maxy, self.maxx = self.screen.getmaxyx()

         self.screen.addstr(self.maxy - 1, 0, '  Arrow keys make selections; <Enter> activates.')

         curses.curs_set(0)

-        config = IsoConfig()

-        rpm_path, install_config = config.configure(options_file, rpms_path, self.maxy, self.maxx, log_path="/var/log")

-        self.screen.erase()

-        installer = InstallerContainer(

-            install_config,

-            self.maxy, self.maxx,

-            True,

-            rpm_path=rpm_path,

+        install_config=None

+        self.cd_mount_path = None

+        ks_path = None

+        cd_search = None

+

+        with open('/proc/cmdline', 'r') as f:

+            kernel_params = shlex.split(f.read().replace('\n', ''))

+

+        for arg in kernel_params:

+            if arg.startswith("ks="):

+                ks_path = arg[len("ks="):]

+            elif arg.startswith("repo="):

+                rpms_path = arg[len("repo="):]

+            elif arg.startswith("photon.media="):

+                cd_search = arg[len("photon.media="):]

+

+        if cd_search is not None:

+            self.mount_cd(cd_search)

+

+        if ks_path is not None:

+            install_config=self.get_ks_config(ks_path)

+

+        # Run installer

+        installer = Installer(

+            maxy=self.maxy,

+            maxx=self.maxx,

+            iso_installer=True,

+            rpm_path=rpms_path,

             log_path="/var/log",

             log_level="debug")

-        installer.install()

+        ui_config={}

+        ui_config['options_file'] = options_file

+

+        installer.configure(install_config, ui_config)

+        self.screen.erase()

+        installer.execute()

+

+    def _load_ks_config(self, path):

+        """kick start configuration"""

+        if path.startswith("http://"):

+            # Do 5 trials to get the kick start

+            # TODO: make sure the installer run after network is up

+            ks_file_error = "Failed to get the kickstart file at {0}".format(path)

+            wait = 1

+            for _ in range(0, 5):

+                err_msg = ""

+                try:

+                    response = requests.get(path, timeout=3)

+                    if response.ok:

+                        return json.loads(response.text)

+                    err_msg = response.text

+                except Exception as e:

+                    err_msg = e

+

+                self.logger.warning(ks_file_error)

+                self.logger.warning("error msg: {0}".format(err_msg))

+                self.logger.warning("retry in a second")

+                time.sleep(wait)

+                wait = wait * 2

+

+            # Something went wrong

+            self.logger.error(ks_file_error)

+            raise Exception(err_msg)

+        else:

+            if path.startswith("cdrom:/"):

+                if self.cd_mount_path is None:

+                    raise Exception("cannot read ks config from cdrom, no cdrom specified")

+                path = os.path.join(self.cd_mount_path, path.replace("cdrom:/", "", 1))

+            return (JsonWrapper(path)).read()

+

+    def get_ks_config(self, ks_path):

+        """Load configuration from kick start file"""

+        install_config = self._load_ks_config(ks_path)

+

+        if 'install_linux_esx' not in install_config and CommandUtils.is_vmware_virtualization():

+            install_config['install_linux_esx'] = True

+

+        return install_config

+

+    def mount_cd(self, cd_search):

+        """Mount the cd with RPMS"""

+        # check if the cd is already mounted

+        if self.cd_mount_path:

+            return

+        mount_path = "/mnt/cdrom"

+

+        # Mount the cd to get the RPMS

+        os.makedirs(mount_path, exist_ok=True)

+

+        # Construct mount cmdline

+        cmdline = ['mount']

+        if cd_search.startswith("UUID="):

+            cmdline.extend(['-U', cd_search[len("UUID="):] ]);

+        elif cd_search.startswith("LABEL="):

+            cmdline.extend(['-L', cd_search[len("LABEL="):] ]);

+        elif cd_search == "cdrom":

+            cmdline.append('/dev/cdrom')

+        else:

+            self.logger.error("Unsupported installer media, check photon.media in kernel cmdline")

+            raise Exception("Can not mount the cd")

+

+        cmdline.extend(['-o', 'ro', mount_path])

+

+        # Retry mount the CD

+        for _ in range(0, 3):

+            process = subprocess.Popen(cmdline)

+            retval = process.wait()

+            if retval == 0:

+                self.cd_mount_path = mount_path

+                return

+            self.logger.error("Failed to mount the cd, retry in a second")

+            time.sleep(1)

+        self.logger.error("Failed to mount the cd, exiting the installer")

+        self.logger.error("check the logs for more details")

+        raise Exception("Can not mount the cd")

+

 if __name__ == '__main__':

     usage = "Usage: %prog [options]"

@@ -1,13 +1,6 @@

 import os

 import sys

-import subprocess

-import shlex

 import re

-import json

-import time

-import crypt

-import string

-from urllib.request import urlopen

 import random

 import requests

 import cracklib

@@ -16,19 +9,18 @@ from custompartition import CustomPartition

 from packageselector import PackageSelector

 from windowstringreader import WindowStringReader

 from confirmwindow import ConfirmWindow

-from jsonwrapper import JsonWrapper

 from selectdisk import SelectDisk

 from license import License

 from linuxselector import LinuxSelector

 from ostreeserverselector import OSTreeServerSelector

 from ostreewindowstringreader import OSTreeWindowStringReader

+from commandutils import CommandUtils

 class IsoConfig(object):

     g_ostree_repo_url = None

     """This class handles iso installer configuration."""

-    def __init__(self):

+    def __init__(self, maxy, maxx):

         self.logger = None

-        self.cd_mount_path = None

         self.alpha_chars = list(range(65, 91))

         self.alpha_chars.extend(range(97, 123))

         self.hostname_accepted_chars = self.alpha_chars

@@ -39,160 +31,10 @@ class IsoConfig(object):

         self.random_id = '%12x' % random.randrange(16**12)

         self.random_hostname = "photon-" + self.random_id.strip()

-    def configure(self, options_file, rpms_path, maxy, maxx, log_path="../stage/LOGS"):

-        self.logger = Logger.get_logger(log_path)

-        ks_path = None

-        rpm_path = rpms_path

-        ks_config = None

-        cd_search = None

+        self.maxy = maxy

+        self.maxx = maxx

+        self.logger = Logger.get_logger()

-        with open('/proc/cmdline', 'r') as f:

-            kernel_params = shlex.split(f.read().replace('\n', ''))

-

-        for arg in kernel_params:

-            if arg.startswith("ks="):

-                ks_path = arg[len("ks="):]

-            elif arg.startswith("repo="):

-                rpm_path = arg[len("repo="):]

-            elif arg.startswith("photon.media="):

-                cd_search = arg[len("photon.media="):]

-

-        if cd_search is not None:

-            self.mount_cd(cd_search)

-

-        if ks_path is not None:

-            ks_config = self.get_config(ks_path)

-

-        if rpm_path is None:

-            # the rpms should be in the cd

-            if self.cd_mount_path is None:

-                self.logger.error("Please specify RPM repo location, as no cdrom is specified. (PXE?)")

-                raise Exception("RPM repo not found")

-            rpm_path = os.path.join(self.cd_mount_path, "RPMS")

-

-        if ks_config:

-            install_config = self.ks_config(options_file, ks_config)

-        else:

-            install_config = self.ui_config(options_file, maxy, maxx)

-

-        self._add_default(install_config)

-

-        issue = self._check_install_config(install_config)

-        if issue:

-            self.logger.error(issue)

-            raise Exception(issue)

-

-        return rpm_path, install_config

-

-    @staticmethod

-    def is_vmware_virtualization():

-        """Detect vmware vm"""

-        process = subprocess.Popen(['systemd-detect-virt'], stdout=subprocess.PIPE)

-        out, err = process.communicate()

-        if err is not None and err != 0:

-            return False

-        return out.decode() == 'vmware\n'

-

-    def get_config(self, path):

-        """kick start configuration"""

-        if path.startswith("http://"):

-            # Do 5 trials to get the kick start

-            # TODO: make sure the installer run after network is up

-            ks_file_error = "Failed to get the kickstart file at {0}".format(path)

-            wait = 1

-            for _ in range(0, 5):

-                err_msg = ""

-                try:

-                    response = requests.get(path, timeout=3)

-                    if response.ok:

-                        return json.loads(response.text)

-                    err_msg = response.text

-                except Exception as e:

-                    err_msg = e

-

-                self.logger.warning(ks_file_error)

-                self.logger.warning("error msg: {0}".format(err_msg))

-                self.logger.warning("retry in a second")

-                time.sleep(wait)

-                wait = wait * 2

-

-            # Something went wrong

-            self.logger.error(ks_file_error)

-            raise Exception(err_msg)

-        else:

-            if path.startswith("cdrom:/"):

-                if self.cd_mount_path is None:

-                    raise Exception("cannot read ks config from cdrom, no cdrom specified")

-                path = os.path.join(self.cd_mount_path, path.replace("cdrom:/", "", 1))

-            return (JsonWrapper(path)).read()

-

-    def mount_cd(self, cd_search):

-        """Mount the cd with RPMS"""

-        # check if the cd is already mounted

-        if self.cd_mount_path:

-            return

-        mount_path = "/mnt/cdrom"

-

-        # Mount the cd to get the RPMS

-        os.makedirs(mount_path, exist_ok=True)

-

-        # Construct mount cmdline

-        cmdline = ['mount']

-        if cd_search.startswith("UUID="):

-            cmdline.extend(['-U', cd_search[len("UUID="):] ]);

-        elif cd_search.startswith("LABEL="):

-            cmdline.extend(['-L', cd_search[len("LABEL="):] ]);

-        elif cd_search == "cdrom":

-            cmdline.append('/dev/cdrom')

-        else:

-            self.logger.error("Unsupported installer media, check photon.media in kernel cmdline")

-            raise Exception("Can not mount the cd")

-

-        cmdline.extend(['-o', 'ro', mount_path])

-

-        # Retry mount the CD

-        for _ in range(0, 3):

-            process = subprocess.Popen(cmdline)

-            retval = process.wait()

-            if retval == 0:

-                self.cd_mount_path = mount_path

-                return

-            self.logger.error("Failed to mount the cd, retry in a second")

-            time.sleep(1)

-        self.logger.error("Failed to mount the cd, exiting the installer")

-        self.logger.error("check the logs for more details")

-        raise Exception("Can not mount the cd")

-

-    def ks_config(self, options_file, ks_config):

-        """Load configuration from file"""

-        del options_file

-        install_config = ks_config

-        if self.is_vmware_virtualization() and 'install_linux_esx' not in install_config:

-            install_config['install_linux_esx'] = True

-

-        base_path = os.path.dirname("build_install_options_all.json")

-        package_list = []

-        if 'packagelist_file' in install_config:

-            package_list = PackageSelector.get_packages_to_install(install_config['packagelist_file'],

-                                                               base_path)

-

-        if 'additional_packages' in install_config:

-            package_list.extend(install_config['additional_packages'])

-        install_config['packages'] = package_list

-

-        if "hostname" in install_config:

-            evalhostname = os.popen('printf ' + install_config["hostname"].strip(" ")).readlines()

-            install_config['hostname'] = evalhostname[0]

-

-        # crypt the password if needed

-        if install_config['password']['crypted']:

-            install_config['password'] = install_config['password']['text']

-        else:

-            install_config['password'] = crypt.crypt(

-                install_config['password']['text'],

-                "$6$" + "".join([random.choice(

-                    string.ascii_letters + string.digits) for _ in range(16)]))

-        return install_config

     @staticmethod

     def validate_hostname(hostname):

@@ -290,23 +132,10 @@ class IsoConfig(object):

             password = str(message)

         return password == text, "Error: " + password

-    @staticmethod

-    def generate_password_hash(password):

-        """Generate hash for the password"""

-        shadow_password = crypt.crypt(

-            password, "$6$" + "".join(

-                [random.choice(

-                    string.ascii_letters + string.digits) for _ in range(16)]))

-        return shadow_password

-

-    def ui_config(self, options_file, maxy, maxx):

+    def configure(self, ui_config):

         """Configuration through UI"""

-        # This represents the installer screen, the bool indicated if

-        # I can go back to this window or not

         install_config = {}

-        install_config['ui_install'] = True

-        items = self.add_ui_pages(options_file, maxy, maxx,

-                                                      install_config)

+        items = self.add_ui_pages(install_config, ui_config, self.maxy, self.maxx)

         index = 0

         while True:

             result = items[index][0]()

@@ -325,12 +154,13 @@ class IsoConfig(object):

                 if index < 0:

                     index = 0

         return install_config

-    def add_ui_pages(self, options_file, maxy, maxx, install_config):

+

+    def add_ui_pages(self, install_config, ui_config, maxy, maxx):

         items = []

         license_agreement = License(maxy, maxx)

         select_disk = SelectDisk(maxy, maxx, install_config)

         custom_partition = CustomPartition(maxy, maxx, install_config)

-        package_selector = PackageSelector(maxy, maxx, install_config, options_file)

+        package_selector = PackageSelector(maxy, maxx, install_config, ui_config['options_file'])

         hostname_reader = WindowStringReader(

             maxy, maxx, 10, 70,

             'hostname',

@@ -344,7 +174,7 @@ class IsoConfig(object):

             True)

         root_password_reader = WindowStringReader(

             maxy, maxx, 10, 70,

-            'password',

+            'shadow_password',

             None, # confirmation error msg if it's a confirmation text

             '*', # echo char

             None, # set of accepted chars

@@ -353,13 +183,13 @@ class IsoConfig(object):

             'Set up root password', 'Root password:', 2, install_config)

         confirm_password_reader = WindowStringReader(

             maxy, maxx, 10, 70,

-            'password',

+            'shadow_password',

             # confirmation error msg if it's a confirmation text

             "Passwords don't match, please try again.",

             '*', # echo char

             None, # set of accepted chars

             None, # validation function of the input

-            IsoConfig.generate_password_hash, # post processing of the input field

+            CommandUtils.generate_password_hash, # post processing of the input field

             'Confirm root password', 'Confirm Root password:', 2, install_config)

         ostree_server_selector = OSTreeServerSelector(maxy, maxx, install_config)

@@ -388,11 +218,13 @@ class IsoConfig(object):

                                       'Start installation? All data on the selected disk will be lost.\n\n'

                                       'Press <Yes> to confirm, or <No> to quit')

+        # This represents the installer screens, the bool indicated if

+        # I can go back to this window or not

         items.append((license_agreement.display, False))

         items.append((select_disk.display, True))

         items.append((custom_partition.display, False))

         items.append((package_selector.display, True))

-        if self.is_vmware_virtualization():

+        if CommandUtils.is_vmware_virtualization():

             linux_selector = LinuxSelector(maxy, maxx, install_config)

             items.append((linux_selector.display, True))

         items.append((hostname_reader.get_user_string, True))

@@ -405,29 +237,3 @@ class IsoConfig(object):

         return items

-    def _add_default(self, install_config):

-        """

-        Add default install_config settings if not specified

-        """

-        # 'bootmode' mode

-        if 'bootmode' not in install_config:

-            arch = subprocess.check_output(['uname', '-m'], universal_newlines=True)

-            if "x86_64" in arch:

-                install_config['bootmode'] = 'dualboot'

-            else:

-                install_config['bootmode'] = 'efi'

-

-        # define 'hostname' as 'photon-<RANDOM STRING>'

-        if "hostname" not in install_config or install_config['hostname'] == "":

-            install_config['hostname'] = "photon-" + self.random_id.strip()

-

-    def _check_install_config(self, install_config):

-        """

-        Sanity check of install_config before its execution.

-        Return error string or None

-        """

-        if not 'disk' in install_config:

-            return "No disk configured"

-

-        return None

-

new file mode 100644

@@ -0,0 +1,97 @@

+Kickstart config file is a json format with following possible parameters:

+

+'additional_packages' same as 'packages'

+

+'bootmode' (optional)

+	Sets the boot type to suppot: EFI, BIOS or both.

+	Acceptible values are: "bios", "efi", "dualboot"

+	"bios" will add special partition (very first) for first stage grub.

+	"efi" will add ESP (Efi Special Partition), format is as FAT and copy

+	there EFI binaries including grub.efi

+	"dualboot" will add two extra partitions for "bios" and "efi" modes.

+	This target will support both modes that can be switched in bios

+	settings without extra actions in the OS.

+	Default value: 'dualboot' for x86_64 and 'efi' for aarch64

+	Example: { 'bootmode': 'bios' }

+

+'disk' (required)

+	Target's disk device file path to install into, such as '/dev/sda'.

+	Loop device is also supported.

+	Example: { 'disk': '/dev/sdb' }

+

+'eject_cdrom' (optional)

+	Eject or not cdrom after installation completed.

+	Boolean: True or False

+	Default value: True

+	Example: { 'eject_cdrom': False }