@@ -1,3 +1,6 @@

+"""

+Photon installer

+"""

 #    Copyright (C) 2015 vmware inc.

 #

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

@@ -15,18 +18,22 @@ from window import Window

 from actionresult import ActionResult

 class Installer(object):

+    """

+    Photon installer

+    """

+    mount_command = "./mk-mount-disk.sh"

+    prepare_command = "./mk-prepare-system.sh"

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

+    chroot_command = "./mk-run-chroot.sh"

+    setup_grub_command = "./mk-setup-grub.sh"

+    unmount_disk_command = "./mk-unmount-disk.sh"

+

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

                  rpm_path="../stage/RPMS", log_path="../stage/LOGS"):

         self.install_config = install_config

-        self.iso_installer = iso_installer

+        self.install_config['iso_installer'] = iso_installer

         self.rpm_path = rpm_path

         self.log_path = log_path

-        self.mount_command = "./mk-mount-disk.sh"

-        self.prepare_command = "./mk-prepare-system.sh"

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

-        self.chroot_command = "./mk-run-chroot.sh"

-        self.setup_grub_command = "./mk-setup-grub.sh"

-        self.unmount_disk_command = "./mk-unmount-disk.sh"

         if 'working_directory' in self.install_config:

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

@@ -34,127 +41,93 @@ class Installer(object):

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

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

         self.rpms_tobeinstalled = None

-        self.restart_command = "shutdown"

-        if self.iso_installer:

+        if self.install_config['iso_installer']:

             self.output = open(os.devnull, 'w')

-        else:

-            self.output = None

-

-        if self.iso_installer:

             #initializing windows

-            self.maxy = maxy

-            self.maxx = maxx

-            self.height = 10

-            self.width = 75

-            self.progress_padding = 5

-

-            self.progress_width = self.width - self.progress_padding

-            self.starty = (self.maxy - self.height) // 2

-            self.startx = (self.maxx - self.width) // 2

-            self.window = Window(self.height, self.width, self.maxy, self.maxx,

+            height = 10

+            width = 75

+            progress_padding = 5

+

+            progress_width = width - progress_padding

+            starty = (maxy - height) // 2

+            startx = (maxx - width) // 2

+            self.window = Window(height, width, maxy, maxx,

                                  'Installing Photon', False)

-            self.progress_bar = ProgressBar(self.starty + 3,

-                                            self.startx + self.progress_padding // 2,

-                                            self.progress_width)

+            self.progress_bar = ProgressBar(starty + 3,

+                                            startx + progress_padding // 2,

+                                            progress_width)

+        else:

+            self.output = None

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

-    # This will be called if the installer interrupted by Ctrl+C or exception

-    def exit_gracefully(self, signal1, frame1):

-        del signal1

-        del frame1

-        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...')

-            self.window.content_window().getch()

-

-        modules.commons.dump(modules.commons.LOG_FILE_NAME)

-        sys.exit(1)

-

     def install(self, params):

+        """

+        Install photon system and handle exception

+        """

         del params

         try:

-            return self.unsafe_install()

+            return self._unsafe_install()

         except Exception as inst:

-            if self.iso_installer:

+            if self.install_config['iso_installer']:

                 modules.commons.log(modules.commons.LOG_ERROR, repr(inst))

                 self.exit_gracefully(None, None)

             else:

                 raise

-    def unsafe_install(self):

-        self.setup_install_repo()

-        self.execute_modules(modules.commons.PRE_INSTALL)

-

-        self.initialize_system()

-        self.install_packages()

-        self.enable_network_in_chroot()

-        self.finalize_system()

-

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

-            # Execute post installation modules

-            self.execute_modules(modules.commons.POST_INSTALL)

-            if os.path.exists(modules.commons.KS_POST_INSTALL_LOG_FILE_NAME):

-                shutil.copy(modules.commons.KS_POST_INSTALL_LOG_FILE_NAME,

-                            self.photon_root + '/var/log/')

-

-            if self.iso_installer and os.path.isdir("/sys/firmware/efi"):

-                self.install_config['boot'] = 'efi'

-            # install grub

-            if 'boot_partition_number' not in self.install_config['disk']:

-                self.install_config['disk']['boot_partition_number'] = 1

+    def _unsafe_install(self):

+        """

+        Install photon system

+        """

+        self._setup_install_repo()

+        self._initialize_system()

+        self._install_packages()

+        self._enable_network_in_chroot()

+        self._finalize_system()

+

+        self._disable_network_in_chroot()

+        self._cleanup_and_exit()

+        return ActionResult(True, None)

-            try:

-                if self.install_config['boot'] == 'bios':

-                    process = subprocess.Popen(

-                        [self.setup_grub_command, '-w', self.photon_root,

-                         "bios", self.install_config['disk']['disk'],

-                         self.install_config['disk']['root'],

-                         self.install_config['disk']['boot'],

-                         self.install_config['disk']['bootdirectory'],

-                         str(self.install_config['disk']['boot_partition_number'])],

-                        stdout=self.output)

-                elif self.install_config['boot'] == 'efi':

-                    process = subprocess.Popen(

-                        [self.setup_grub_command, '-w', self.photon_root,

-                         "efi", self.install_config['disk']['disk'],

-                         self.install_config['disk']['root'],

-                         self.install_config['disk']['boot'],

-                         self.install_config['disk']['bootdirectory'],

-                         str(self.install_config['disk']['boot_partition_number'])],

-                        stdout=self.output)

-            except:

-                #install bios if variable is not set.

-                process = subprocess.Popen(

-                    [self.setup_grub_command, '-w', self.photon_root,

-                     "bios", self.install_config['disk']['disk'],

-                     self.install_config['disk']['root'],

-                     self.install_config['disk']['boot'],

-                     self.install_config['disk']['bootdirectory'],

-                     str(self.install_config['disk']['boot_partition_number'])],

-                    stdout=self.output)

-            retval = process.wait()

+    def exit_gracefully(self, signal1, frame1):

+        """

+        This will be called if the installer interrupted by Ctrl+C, exception

+        or other failures

+        """

+        del signal1

+        del frame1

+        if self.install_config['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...')

+            self.window.content_window().getch()

-            self.update_fstab()

-        self.disable_network_in_chroot()

+        modules.commons.dump(modules.commons.LOG_FILE_NAME)

+        sys.exit(1)

-        command = [self.unmount_disk_command, '-w', self.photon_root]

+    def _cleanup_and_exit(self):

+        """

+        Unmount the disk, eject cd and exit

+        """

+        command = [Installer.unmount_disk_command, '-w', self.photon_root]

         if not self.install_config['iso_system']:

-            command.extend(self.generate_partitions_param(reverse=True))

+            command.extend(self._generate_partitions_param(reverse=True))

         process = subprocess.Popen(command, stdout=self.output)

         retval = process.wait()

-

-        if self.iso_installer:

+        if retval != 0:

+            modules.commons.log(modules.commons.LOG_ERROR, "Failed to unmount disks")

+        if self.install_config['iso_installer']:

             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))

-            self.eject_cdrom()

-        return ActionResult(True, None)

+            self._eject_cdrom()

-    def copy_rpms(self):

+    def _copy_rpms(self):

+        """

+        Prepare RPM list and copy rpms

+        """

         # prepare the RPMs list

         json_pkg_to_rpm_map = JsonWrapper(self.install_config["pkg_to_rpm_map_file"])

         pkg_to_rpm_map = json_pkg_to_rpm_map.read()

@@ -174,38 +147,70 @@ class Installer(object):

         for rpm in self.rpms_tobeinstalled:

             shutil.copy(rpm['path'], self.photon_root + '/RPMS/')

-    def copy_files(self):

+    def _copy_files(self):

+        """

+        Copy the rpm files and instal scripts.

+        """

         # Make the photon_root directory if not exits

         process = subprocess.Popen(['mkdir', '-p', self.photon_root], stdout=self.output)

         retval = process.wait()

+        if retval != 0:

+            modules.commons.log(modules.commons.LOG_ERROR, "Fail to create the root directory")

+            self.exit_gracefully(None, None)

         # Copy the installer files

         process = subprocess.Popen(['cp', '-r', "../installer", self.photon_root],

                                    stdout=self.output)

         retval = process.wait()

+        if retval != 0:

+            modules.commons.log(modules.commons.LOG_ERROR, "Fail to copy install scripts")

+            self.exit_gracefully(None, None)

         # Create the rpms directory

         process = subprocess.Popen(['mkdir', '-p', self.photon_root + '/RPMS'],

                                    stdout=self.output)

         retval = process.wait()

-        self.copy_rpms()

-

-    def bind_installer(self):

+        if retval != 0:

+            modules.commons.log(modules.commons.LOG_ERROR, "Fail to create the rpms directory")

+            self.exit_gracefully(None, None)

+        self._copy_rpms()

+

+    def _bind_installer(self):

+        """

+        Make the photon_root/installer directory if not exits

+        The function finalize_system will access the file /installer/mk-finalize-system.sh

+        after chroot to photon_root.

+        Bind the /installer folder to self.photon_root/installer, so that after chroot

+        to photon_root,

+        the file can still be accessed as /installer/mk-finalize-system.sh.

+        """

         # Make the photon_root/installer directory if not exits

-        process = subprocess.Popen(['mkdir', '-p', os.path.join(self.photon_root, "installer")],

+        if(subprocess.call(['mkdir', '-p',

+                            os.path.join(self.photon_root, "installer")]) != 0 or

+           subprocess.call(['mount', '--bind', '/installer',

+                            os.path.join(self.photon_root, "installer")]) != 0):

+            modules.commons.log(modules.commons.LOG_ERROR, "Fail to bind installer")

+            self.exit_gracefully(None, None)

+    def _unbind_installer(self):

+        # unmount the installer directory

+        process = subprocess.Popen(['umount', os.path.join(self.photon_root,

+                                                           "installer")],

                                    stdout=self.output)

         retval = process.wait()

-        # The function finalize_system will access the file /installer/mk-finalize-system.sh

-        # after chroot to photon_root.

-        # Bind the /installer folder to self.photon_root/installer, so that after chroot

-        # to photon_root,

-        # the file can still be accessed as /installer/mk-finalize-system.sh.

-        process = subprocess.Popen(['mount', '--bind', '/installer',

-                                    os.path.join(self.photon_root, "installer")],

+        if retval != 0:

+            modules.commons.log(modules.commons.LOG_ERROR,

+                                "Fail to unbind the installer directory")

+        # remove the installer directory

+        process = subprocess.Popen(['rm', '-rf', os.path.join(self.photon_root, "installer")],

                                    stdout=self.output)

         retval = process.wait()

-

-    def bind_repo_dir(self):

+        if retval != 0:

+            modules.commons.log(modules.commons.LOG_ERROR,

+                                "Fail to remove the installer directory")

+    def _bind_repo_dir(self):

+        """

+        Bind repo dir for tdnf installation

+        """

         rpm_cache_dir = self.photon_root + '/cache/tdnf/photon-iso/rpms'

         if self.rpm_path.startswith("https://") or self.rpm_path.startswith("http://"):

             return

@@ -213,7 +218,11 @@ class Installer(object):

                 subprocess.call(['mount', '--bind', self.rpm_path, rpm_cache_dir]) != 0):

             modules.commons.log(modules.commons.LOG_ERROR, "Fail to bind cache rpms")

             self.exit_gracefully(None, None)

-    def unbind_repo_dir(self):

+

+    def _unbind_repo_dir(self):

+        """

+        Unbind repo dir after installation

+        """

         rpm_cache_dir = self.photon_root + '/cache/tdnf/photon-iso/rpms'

         if self.rpm_path.startswith("https://") or self.rpm_path.startswith("http://"):

             return

@@ -222,7 +231,10 @@ class Installer(object):

             modules.commons.log(modules.commons.LOG_ERROR, "Fail to unbind cache rpms")

             self.exit_gracefully(None, None)

-    def update_fstab(self):

+    def _update_fstab(self):

+        """

+        update fstab

+        """

         with open(os.path.join(self.photon_root, "etc/fstab"), "w") as fstab_file:

             fstab_file.write("#system\tmnt-pt\ttype\toptions\tdump\tfsck\n")

@@ -253,7 +265,10 @@ class Installer(object):

             # Add the cdrom entry

             fstab_file.write("/dev/cdrom\t/mnt/cdrom\tiso9660\tro,noauto\t0\t0\n")

-    def generate_partitions_param(self, reverse=False):

+    def _generate_partitions_param(self, reverse=False):

+        """

+        Generate partition param for mount command

+        """

         if reverse:

             step = -1

         else:

@@ -266,84 +281,128 @@ class Installer(object):

             params.extend(['--partitionmountpoint', partition["path"], partition["mountpoint"]])

         return params

-    def initialize_system(self):

+    def _initialize_system(self):

+        """

+        Prepare the system to install photon

+        """

         #Setup the disk

         if not self.install_config['iso_system']:

-            command = [self.mount_command, '-w', self.photon_root]

-            command.extend(self.generate_partitions_param())

+            command = [Installer.mount_command, '-w', self.photon_root]

+            command.extend(self._generate_partitions_param())

             process = subprocess.Popen(command, stdout=self.output)

             retval = process.wait()

+            if retval != 0:

+                modules.commons.log(modules.commons.LOG_INFO,

+                                    "Failed to setup the disk for installation")

+                self.exit_gracefully(None, None)

-        if self.iso_installer:

-            self.bind_installer()

-            self.bind_repo_dir()

-            process = subprocess.Popen([self.prepare_command, '-w', self.photon_root, 'install'],

+        if self.install_config['iso_installer']:

+            self._bind_installer()

+            self._bind_repo_dir()

+            process = subprocess.Popen([Installer.prepare_command, '-w',

+                                        self.photon_root, 'install'],

                                        stdout=self.output)

             retval = process.wait()

+            if retval != 0:

+                modules.commons.log(modules.commons.LOG_INFO,

+                                    "Failed to bind the installer and repo needed by tdnf")

+                self.exit_gracefully(None, None)

         else:

-            self.copy_files()

+            self._copy_files()

             #Setup the filesystem basics

-            process = subprocess.Popen([self.prepare_command, '-w', self.photon_root],

+            process = subprocess.Popen([Installer.prepare_command, '-w', self.photon_root],

                                        stdout=self.output)

             retval = process.wait()

+            if retval != 0:

+                modules.commons.log(modules.commons.LOG_INFO,

+                                    "Failed to setup the file systems basics")

+                self.exit_gracefully(None, None)

-    def finalize_system(self):

+    def _finalize_system(self):

+        """

+        Finalize the system after the installation

+        """

         #Setup the disk

-        process = subprocess.Popen([self.chroot_command, '-w', self.photon_root,

-                                    self.finalize_command, '-w', self.photon_root],

+        process = subprocess.Popen([Installer.chroot_command, '-w', self.photon_root,

+                                    Installer.finalize_command, '-w', self.photon_root],

                                    stdout=self.output)

         retval = process.wait()

-        if self.iso_installer:

+        if retval != 0:

+            modules.commons.log(modules.commons.LOG_ERROR,

+                                "Fail to setup th target system after the installation")

+

+        if self.install_config['iso_installer']:

             modules.commons.dump(modules.commons.LOG_FILE_NAME)

             shutil.copy(modules.commons.LOG_FILE_NAME, self.photon_root + '/var/log/')

             shutil.copy(modules.commons.TDNF_LOG_FILE_NAME, self.photon_root +

                         '/var/log/')

-            # unmount the installer directory

-            process = subprocess.Popen(['umount', os.path.join(self.photon_root,

-                                                               "installer")],

-                                       stdout=self.output)

-            retval = process.wait()

-            # remove the installer directory

-            process = subprocess.Popen(['rm', '-rf', os.path.join(self.photon_root, "installer")],

-                                       stdout=self.output)

-            retval = process.wait()

-            self.unbind_repo_dir()

+            self._unbind_installer()

+            self._unbind_repo_dir()

             # Disable the swap file

             process = subprocess.Popen(['swapoff', '-a'], stdout=self.output)

             retval = process.wait()

+            if retval != 0:

+                modules.commons.log(modules.commons.LOG_ERROR,

+                                    "Fail to swapoff")

             # remove the tdnf cache directory and the swapfile.

             process = subprocess.Popen(['rm', '-rf', os.path.join(self.photon_root, "cache")],

                                        stdout=self.output)

             retval = process.wait()

+            if retval != 0:

+                modules.commons.log(modules.commons.LOG_ERROR,

+                                    "Fail to remove the cache")

+        if not self.install_config['iso_system']:

+            # Execute post installation modules

+            self._execute_modules(modules.commons.POST_INSTALL)

+            if os.path.exists(modules.commons.KS_POST_INSTALL_LOG_FILE_NAME):

+                shutil.copy(modules.commons.KS_POST_INSTALL_LOG_FILE_NAME,

+                            self.photon_root + '/var/log/')

-    def install_package(self, rpm_file_names):

-

-        rpms = set(rpm_file_names)

-        rpm_paths = []

-        for root, _, files in os.walk(self.rpm_path):

-            for f in files:

-                if f in rpms:

-                    rpm_paths.append(os.path.join(root, f))

-

-        # --nodeps is for hosts which do not support rich dependencies

-        rpm_params = ['--nodeps', '--root', self.photon_root, '--dbpath',

-                      '/var/lib/rpm']

+            if self.install_config['iso_installer'] and os.path.isdir("/sys/firmware/efi"):

+                self.install_config['boot'] = 'efi'

+            # install grub

+            if 'boot_partition_number' not in self.install_config['disk']:

+                self.install_config['disk']['boot_partition_number'] = 1

-        if (('type' in self.install_config and

-             (self.install_config['type'] in ['micro', 'minimal'])) or

-                self.install_config['iso_system']):

-            rpm_params.append('--excludedocs')

+            try:

+                if self.install_config['boot'] == 'bios':

+                    process = subprocess.Popen(

+                        [Installer.setup_grub_command, '-w', self.photon_root,

+                         "bios", self.install_config['disk']['disk'],

+                         self.install_config['disk']['root'],

+                         self.install_config['disk']['boot'],

+                         self.install_config['disk']['bootdirectory'],

+                         str(self.install_config['disk']['boot_partition_number'])],

+                        stdout=self.output)

+                elif self.install_config['boot'] == 'efi':

+                    process = subprocess.Popen(

+                        [Installer.setup_grub_command, '-w', self.photon_root,

+                         "efi", self.install_config['disk']['disk'],

+                         self.install_config['disk']['root'],

+                         self.install_config['disk']['boot'],

+                         self.install_config['disk']['bootdirectory'],

+                         str(self.install_config['disk']['boot_partition_number'])],

+                        stdout=self.output)

+            except:

+                #install bios if variable is not set.

+                process = subprocess.Popen(

+                    [Installer.setup_grub_command, '-w', self.photon_root,

+                     "bios", self.install_config['disk']['disk'],

+                     self.install_config['disk']['root'],

+                     self.install_config['disk']['boot'],

+                     self.install_config['disk']['bootdirectory'],

+                     str(self.install_config['disk']['boot_partition_number'])],

+                    stdout=self.output)

+            retval = process.wait()

-        modules.commons.log(modules.commons.LOG_INFO,

-                            "installing packages {0}, with params {1}"

-                            .format(rpm_paths, rpm_params))

-        process = subprocess.Popen(['rpm', '-Uvh'] + rpm_params + rpm_paths,

-                                   stderr=subprocess.STDOUT)

-        return process.wait()

+            self._update_fstab()

-    def execute_modules(self, phase):

+    def _execute_modules(self, phase):

+        """

+        Execute the scripts in the modules folder

+        """

         sys.path.append("./modules")

         modules_paths = glob.glob('modules/m_*.py')

         for mod_path in modules_paths:

@@ -378,7 +437,10 @@ class Installer(object):

             mod.execute(self.install_config, self.photon_root)

-    def adjust_packages_for_vmware_virt(self):

+    def _adjust_packages_for_vmware_virt(self):

+        """

+        Install linux_esx on Vmware virtual machine if requested

+        """

         try:

             if self.install_config['install_linux_esx']:

                 selected_packages = self.install_config['packages']

@@ -394,14 +456,17 @@ class Installer(object):

         except KeyError:

             pass

-    def setup_install_repo(self):

-        if self.iso_installer:

+    def _setup_install_repo(self):

+        """

+        Setup the tdnf repo for installation

+        """

+        if self.install_config['iso_installer']:

             self.window.show_window()

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

             self.progress_bar.show()

             #self.rpm_path = "https://dl.bintray.com/vmware/photon_release_1.0_TP2_x86_64"

             if self.rpm_path.startswith("https://") or self.rpm_path.startswith("http://"):

-                cmdoption = 's/baseurl.*/baseurl={}/g'.format(self.rpm_path.replace('/', '\/'))

+                cmdoption = 's/baseurl.*/baseurl={}/g'.format(self.rpm_path.replace('/', r'\/'))

                 process = subprocess.Popen(['sed', '-i', cmdoption,

                                             '/etc/yum.repos.d/photon-iso.repo'])

                 retval = process.wait()

@@ -409,31 +474,28 @@ class Installer(object):

                     modules.commons.log(modules.commons.LOG_INFO, "Failed to reset repo")

                     self.exit_gracefully(None, None)

-            cmdoption = ('s/cachedir=\/var/cachedir={}/g'

-                         .format(self.photon_root.replace('/', '\/')))

+            cmdoption = (r's/cachedir=\/var/cachedir={}/g'

+                         .format(self.photon_root.replace('/', r'\/')))

             process = subprocess.Popen(['sed', '-i', cmdoption, '/etc/tdnf/tdnf.conf'])

             retval = process.wait()

             if retval != 0:

                 modules.commons.log(modules.commons.LOG_INFO, "Failed to reset tdnf cachedir")

                 self.exit_gracefully(None, None)

-    def install_packages(self):

-        if self.iso_installer:

-            self.tdnf_install_packages()

+    def _install_packages(self):

+        """

+        Install packages using tdnf or rpm command

+        """

+        if self.install_config['iso_installer']:

+            self._tdnf_install_packages()

         else:

-        #install packages

-            rpms = []

-            for rpm in self.rpms_tobeinstalled:

-                # We already installed the filesystem in the preparation

-                if rpm['package'] == 'filesystem':

-                    continue

-                rpms.append(rpm['filename'])

-            return_value = self.install_package(rpms)

-            if return_value != 0:

-                self.exit_gracefully(None, None)

+            self._rpm_install_packages()

-    def tdnf_install_packages(self):

-        self.adjust_packages_for_vmware_virt()

+    def _tdnf_install_packages(self):

+        """

+        Install packages using tdnf command

+        """

+        self._adjust_packages_for_vmware_virt()

         selected_packages = self.install_config['packages']

         state = 0

         packages_to_install = {}

@@ -488,7 +550,46 @@ class Installer(object):

                 self.exit_gracefully(None, None)

         self.progress_bar.show_loading('Finalizing installation')

-    def eject_cdrom(self):

+    def _rpm_install_packages(self):

+        """

+        Install packages using rpm command

+        """

+        rpms = []

+        for rpm in self.rpms_tobeinstalled:

+            # We already installed the filesystem in the preparation

+            if rpm['package'] == 'filesystem':

+                continue

+            rpms.append(rpm['filename'])

+        rpms = set(rpms)

+        rpm_paths = []

+        for root, _, files in os.walk(self.rpm_path):

+            for file in files:

+                if file in rpms:

+                    rpm_paths.append(os.path.join(root, file))

+

+        # --nodeps is for hosts which do not support rich dependencies

+        rpm_params = ['--nodeps', '--root', self.photon_root, '--dbpath',

+                      '/var/lib/rpm']

+

+        if (('type' in self.install_config and

+             (self.install_config['type'] in ['micro', 'minimal'])) or

+                self.install_config['iso_system']):

+            rpm_params.append('--excludedocs')

+

+        modules.commons.log(modules.commons.LOG_INFO,

+                            "installing packages {0}, with params {1}"

+                            .format(rpm_paths, rpm_params))

+        process = subprocess.Popen(['rpm', '-Uvh'] + rpm_params + rpm_paths,

+                                   stderr=subprocess.STDOUT)

+        return_value = process.wait()

+        if return_value != 0:

+            self.exit_gracefully(None, None)

+

+

+    def _eject_cdrom(self):

+        """

+        Eject the cdrom on request

+        """

         eject_cdrom = True

         if 'ui_install' in self.install_config:

             self.window.content_window().getch()

@@ -498,10 +599,16 @@ class Installer(object):

             process = subprocess.Popen(['eject', '-r'], stdout=self.output)

             process.wait()

-    def enable_network_in_chroot(self):

+    def _enable_network_in_chroot(self):

+        """

+        Enable network in chroot

+        """

         if os.path.exists("/etc/resolv.conf"):

             shutil.copy("/etc/resolv.conf", self.photon_root + '/etc/.')

-    def disable_network_in_chroot(self):

+    def _disable_network_in_chroot(self):

+        """

+        disable network in chroot

+        """

         if os.path.exists(self.photon_root + '/etc/resolv.conf'):

             os.remove(self.photon_root + '/etc/resolv.conf')