@@ -80,11 +80,15 @@ class Installer(object):

             self.output = None

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

-    def install(self, params):

+    def install(self):

         """

         Install photon system and handle exception

         """

-        del params

+        if self.install_config['iso_installer']:

+            self.window.show_window()

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

+            self.progress_bar.show()

+

         try:

             return self._unsafe_install()

         except Exception as inst:

@@ -98,6 +102,7 @@ class Installer(object):

         """

         Install photon system

         """

+        self._format_disk()

         self._setup_install_repo()

         self._initialize_system()

         self._install_packages()

@@ -139,6 +144,8 @@ class Installer(object):

             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:

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

             self._eject_cdrom()

     def _create_installrpms_list(self):

@@ -304,6 +311,7 @@ class Installer(object):

             self.exit_gracefully(None, None)

         if self.install_config['iso_installer']:

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

             self._bind_installer()

             self._bind_repo_dir()

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

@@ -471,15 +479,35 @@ class Installer(object):

         except KeyError:

             pass

+    def _format_disk(self):

+        """

+        Partition and format the disk

+        """

+        # skip partitioning if installer was called from image

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

+            return

+

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

+

+        if 'partitions' in self.install_config:

+            partitions = self.install_config['partitions']

+        else:

+            partitions = modules.commons.default_partitions

+

+        # do partitioning

+        partitions_data = modules.commons.partition_disk(self.install_config['disk'], partitions)

+

+        if partitions_data == None:

+            raise Exception("Partitioning failed.")

+        self.install_config['disk'] = partitions_data

+

+

     def _setup_install_repo(self):

         """

         Setup the tdnf repo for installation

         """

         if self.install_config['iso_installer']:

             keepcache = False

-            self.window.show_window()

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

-            self.progress_bar.show()

             with open(self.tdnf_repo_path, "w") as repo_file:

                 repo_file.write("[photon-local]\n")

                 repo_file.write("name=VMWare Photon installer repo\n")

@@ -611,8 +639,6 @@ class Installer(object):

         Eject the cdrom on request

         """

         eject_cdrom = True

-        if 'ui_install' in self.install_config:

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

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

             eject_cdrom = False

         if eject_cdrom:

@@ -18,7 +18,7 @@ class InstallerContainer(object):

         self.log_path = log_path

         self.log_level = log_level

-    def install(self, params):

+    def install(self):

         installer = None

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

@@ -28,4 +28,4 @@ class InstallerContainer(object):

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

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

-        return installer.install(params)

+        return installer.install()

@@ -26,7 +26,7 @@ class IsoInstaller(object):

         config = IsoConfig()

         rpm_path, install_config = config.Configure(options_file, rpms_path, self.maxy, self.maxx)

-        self.screen.clear()

+        self.screen.erase()

         installer = InstallerContainer(

             install_config,

             self.maxy, self.maxx,

@@ -34,7 +34,7 @@ class IsoInstaller(object):

             rpm_path=rpm_path,

             log_path="/var/log")

-        installer.install(None)

+        installer.install()

 if __name__ == '__main__':

     usage = "Usage: %prog [options]"

@@ -15,6 +15,7 @@ import modules.commons

 from partitionISO import PartitionISO

 from packageselector import PackageSelector

 from windowstringreader import WindowStringReader

+from confirmwindow import ConfirmWindow

 from jsonwrapper import JsonWrapper

 from selectdisk import SelectDisk

 from license import License

@@ -70,6 +71,13 @@ class IsoConfig(object):

             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:

+            raise Exception(issue)

+

         return rpm_path, install_config

     @staticmethod

@@ -172,18 +180,9 @@ class IsoConfig(object):

             package_list.extend(install_config['additional_packages'])

         install_config['packages'] = package_list

-        if 'partitions' in install_config:

-            partitions = install_config['partitions']

-        else:

-            partitions = modules.commons.default_partitions

-

-        install_config['disk'] = modules.commons.partition_disk(install_config['disk'], partitions)

-

         if "hostname" in install_config:

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

             install_config['hostname'] = evalhostname[0]

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

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

         # crypt the password if needed

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

@@ -306,15 +305,19 @@ class IsoConfig(object):

         # I can go back to this window or not

         install_config = {}

         install_config['ui_install'] = True

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

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

                                                       install_config)

         index = 0

         while True:

-            result = items[index][0](None)

+            result = items[index][0]()

             if result.success:

                 index += 1

                 if index == len(items):

-                    break

+                    # confirm window

+                    if result.result['yes']:

+                        break

+                    else:

+                        exit(0)

             else:

                 index -= 1

                 while index >= 0 and items[index][1] is False:

@@ -380,23 +383,51 @@ class IsoConfig(object):

             None, # post processing of the input field

             'Please provide the Refspec in OSTree repo', 'OSTree Repo Refspec:', 2, install_config,

             "photon/3.0/x86_64/minimal")

+        confirm_window = ConfirmWindow(11, 60, maxy, maxx,

+                                      (maxy - 11) // 2 + 7,

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

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

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

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

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

-        items.append((select_disk.guided_partitions, False))

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

-        select_linux_index = -1

         if self.is_vmware_virtualization():

             linux_selector = LinuxSelector(maxy, maxx, install_config)

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

-            select_linux_index = items.index((linux_selector.display, True))

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

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

         items.append((confirm_password_reader.get_user_string, False))

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

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

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

+        items.append((confirm_window.do_action, True))

+

+        return items

+

+    def _add_default(self, install_config):

+        """

+        Add default install_config settings if not specified

+        """

+        # 'boot' mode

+        if 'boot' not in install_config:

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

+            if "x86" in arch:

+                install_config['boot'] = 'dualboot'

+            else:

+                install_config['boot'] = '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 items, select_linux_index

+        return None

@@ -23,7 +23,7 @@ class License(object):

         self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx,

                              'Welcome to the Photon installer', False)

-    def display(self, params):

+    def display(self):

         accept_decline_items = [('<Accept>', self.accept_function),

                                 ('<Cancel>', self.exit_function)]

@@ -36,7 +36,7 @@ class LinuxSelector(object):

         self.install_config['install_linux_esx'] = is_linux_esx

         return ActionResult(True, None)

-    def display(self, params):

+    def display(self):

         self.window.addstr(0, 0, 'The installer has detected that you are installing')

         self.window.addstr(1, 0, 'Photon OS on a VMware hypervisor.')

         self.window.addstr(2, 0, 'Which type of Linux kernel would you like to install?')

@@ -121,7 +121,7 @@ class Menu(Action):

                 self.window.addch(index + up + self.filled, self.width - 2, curses.ACS_CKBOARD)

     def refresh(self, highligh=True):

-        self.window.clear()

+#        self.window.clear()

         for index, item in enumerate(self.items_strings):

             if index < self.head_position:

                 continue

@@ -35,7 +35,7 @@ class OSTreeServerSelector(object):

         self.install_config['default_repo'] = is_default_repo

         return ActionResult(True, None)

-    def display(self, params):

+    def display(self):

         if self.install_config['type'] == 'ostree_host':

             return self.window.do_action()

         return ActionResult(True, None)

@@ -11,7 +11,7 @@ class OSTreeWindowStringReader(WindowStringReader):

     def __init__(self, maxy, maxx, height, width, field, confirmation_err_msg, echo_char, accepted_chars, validation_fn, conversion_fn, title, display_string, inputy, install_config, default_string = None):

         WindowStringReader.__init__(self, maxy, maxx, height, width, field, confirmation_err_msg, echo_char, accepted_chars, validation_fn, conversion_fn, title, display_string, inputy, install_config, default_string)

-    def get_user_string(self, params):

+    def get_user_string(self):

         if self.install_config['type'] == 'ostree_host' and not self.install_config['default_repo']:

             return self.window.do_action()

         return ActionResult(True, None)

@@ -81,8 +81,8 @@ class PackageSelector(object):

         self.install_config['additional-files'] = selected_item_params[2]

         return ActionResult(True, {'custom': False})

-    def custom_packages(self, params):

+    def custom_packages(self):

         return ActionResult(True, {'custom': True})

-    def display(self, params):

+    def display(self):

         return self.window.do_action()

@@ -35,10 +35,7 @@ class PartitionISO(object):

                              'Welcome to the Photon installer', False, can_go_next=False)

         Device.refresh_devices()

-    def display(self, params):

-        if 'skipPrevs' in self.install_config and self.install_config['skipPrevs'] == True:

-            self.delete()

-            return ActionResult(False, {'goBack':True})

+    def display(self):

         if 'autopartition' in self.install_config and self.install_config['autopartition'] == True:

             return ActionResult(True, None)

         if ('delete_partition' in self.install_config and

@@ -162,11 +159,11 @@ class PartitionISO(object):

             self.install_config['partitionsnumber'] = self.install_config['partitionsnumber'] + 1

         #parse the input in install config

-        return self.display(False)

+        return self.display()

     def delete_function(self):

         self.delete()

-        return self.display(False)

+        return self.display()

     def go_back(self):

         self.delete()

@@ -184,7 +181,7 @@ class PartitionISO(object):

                                            'Partition information cannot be empty',

                                            info=True)

             confirm_window.do_action()

-            return self.display(False)

+            return self.display()

         #must have /

         if not self.has_slash:

             window_height = 9

@@ -194,10 +191,25 @@ class PartitionISO(object):

                                            self.maxx, window_starty, 'Missing /',

                                            info=True)

             confirm_window.do_action()

-            return self.display(False)

+            return self.display()

         self.window.hide_window()

         self.text_pane.hide()

+

+        partitions = []

+        for i in range(int(self.install_config['partitionsnumber'])):

+            if len(self.install_config[str(i)+'partition_info'+str(0)]) == 0:

+                sizedata = 0

+            else:

+                sizedata = int(self.install_config[str(i) + 'partition_info' + str(0)])

+            mtdata = self.install_config[str(i) + 'partition_info' + str(2)]

+            typedata = self.install_config[str(i) + 'partition_info'+str(1)]

+

+            partitions = partitions + [{"mountpoint": mtdata,

+                                        "size": sizedata,

+                                        "filesystem": typedata},]

+        self.install_config['partitions'] = partitions

+

         return ActionResult(True, {'goNext':True})

     def delete(self):

@@ -6,9 +6,7 @@ from device import Device

 from window import Window

 from actionresult import ActionResult

 from menu import Menu

-from confirmwindow import ConfirmWindow

 import modules.commons

-from progressbar import ProgressBar

 import subprocess

 class SelectDisk(object):

@@ -26,11 +24,6 @@ class SelectDisk(object):

         self.menu_starty = self.win_starty + 6

         self.menu_height = 5

-        self.progress_padding = 5

-        self.progress_width = self.win_width - self.progress_padding

-        self.progress_bar = ProgressBar(self.win_starty + 6,

-                                        self.win_startx + (self.progress_padding // 2),

-                                        self.progress_width, new_win=True)

         self.disk_buttom_items = []

         self.disk_buttom_items.append(('<Custom>', self.custom_function, False))

@@ -40,74 +33,9 @@ class SelectDisk(object):

                              'Select a disk', True,

                              items=self.disk_buttom_items, menu_helper=self.save_index,

                              position=2, tab_enabled=False)

-        self.partition_window = Window(self.win_height, self.win_width, self.maxy,

-                                       self.maxx, 'Partition', True)

         self.devices = Device.refresh_devices()

-    def guided_partitions(self, params):

-        if not 'diskindex' in self.install_config:

-            return ActionResult(False, None)

-

-        device_index = self.install_config['diskindex']

-

-        menu_height = 9

-        menu_width = 40

-        menu_starty = (self.maxy - menu_height) // 2 + 5

-        self.install_config['delete_partition'] = True

-        confrim_window = ConfirmWindow(menu_height, menu_width, self.maxy,

-                                       self.maxx, menu_starty,

-                                       'This will erase the disk.\nAre you sure?')

-        confirmed = confrim_window.do_action().result['yes']

-

-        if confirmed == False:

-            self.install_config['skipPrevs'] = True

-            return ActionResult(False, {'goBack':True})

-

-        self.install_config['skipPrevs'] = False

-        self.progress_bar.initialize('Partitioning...')

-        self.progress_bar.show()

-        self.progress_bar.show_loading('Partitioning')

-

-        # Do the partitioning

-        if 'partitionsnumber' in self.install_config:

-            if int(self.install_config['partitionsnumber']) == 0:

-                partitions_data = modules.commons.partition_disk(

-                    self.devices[device_index].path, modules.commons.default_partitions)

-            else:

-                partitions = []

-                for i in range(int(self.install_config['partitionsnumber'])):

-                    if len(self.install_config[str(i)+'partition_info'+str(0)]) == 0:

-                        sizedata = 0

-                    else:

-                        sizedata = int(self.install_config[str(i) + 'partition_info' + str(0)])

-                    mtdata = self.install_config[str(i) + 'partition_info' + str(2)]

-                    typedata = self.install_config[str(i) + 'partition_info'+str(1)]

-

-                    partitions = partitions + [{"mountpoint": mtdata,

-                                                "size": sizedata,

-                                                "filesystem": typedata},]

-                partitions_data = modules.commons.partition_disk(

-                    self.devices[device_index].path, partitions)

-        else:

-            partitions_data = modules.commons.partition_disk(

-                self.devices[device_index].path, modules.commons.default_partitions)

-

-        if partitions_data == None:

-            self.partition_window.adderror('Partitioning failed, you may try again')

-        else:

-            self.install_config['disk'] = partitions_data

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

-            if "x86" in arch:

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

-            else:

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

-

-        self.progress_bar.hide()

-        return ActionResult(partitions_data != None, None)

-

-    def display(self, params):

-        if 'skipPrevs' in self.install_config:

-            self.install_config['skipPrevs'] = False

+    def display(self):

         self.window.addstr(0, 0, 'Please select a disk and a method how to partition it:\n' +

                            'Auto - single partition for /, no swap partition.\n' +

                            'Custom - for customized partitioning')

@@ -133,13 +61,14 @@ class SelectDisk(object):

     def save_index(self, device_index):

         self.install_config['diskindex'] = device_index

+        self.install_config['disk'] = self.devices[device_index].path

         return ActionResult(True, None)

-    def auto_function(self, params):    #default is no partition

+    def auto_function(self):    #default is no partition

         self.install_config['autopartition'] = True

         self.install_config['partitionsnumber'] = 0

         return ActionResult(True, None)

-    def custom_function(self, params):  #custom minimize partition number is 1

+    def custom_function(self):  #custom minimize partition number is 1

         self.install_config['autopartition'] = False

         return ActionResult(True, None)

@@ -173,7 +173,7 @@ class TextPane(Action):

                 self.window.addch(index + up + self.filled, self.width - 2, curses.ACS_CKBOARD)

     def refresh(self):

-        self.window.clear()

+        self.window.erase()

         for index, line in enumerate(self.lines):

             if index < self.head_position:

                 continue

@@ -71,7 +71,7 @@ class Window(Action):

         self.shadowpanel = curses.panel.new_panel(self.shadowwin)

         self.action_panel = action_panel

-        self.refresh(0, True)

+#        self.refresh(0, True)

         self.hide_window()

     def update_next_item(self):

@@ -80,7 +80,7 @@ class Window(Action):

         self.tab_enabled = False

-    def next_function(self, params):

+    def next_function(self):

         return ActionResult(True, None)

     def set_action_panel(self, action_panel):

@@ -104,7 +104,7 @@ class Window(Action):

                 if self.menu_helper:

                     self.menu_helper(params)

-            result = self.items[self.position-1][1](None)

+            result = self.items[self.position-1][1]()

             if result.success:

                 self.hide_window()

                 self.action_panel.hide()

@@ -130,7 +130,7 @@ class Window(Action):

                     action_result.result['goNext']):

                 return ActionResult(True, None)

             if self.position != 0:    #saving the disk index

-                self.items[self.position-1][1](None)

+                self.items[self.position-1][1]()

             if self.items:

                 return self.update_menu(action_result)

             self.hide_window()

@@ -184,7 +184,7 @@ class Window(Action):

                             params = action_result.result['diskIndex']

                             if self.menu_helper:

                                 self.menu_helper(params)

-                        result = self.items[self.position-1][1](None)

+                        result = self.items[self.position-1][1]()

                         if result.success:

                             self.hide_window()

                             self.action_panel.hide()

@@ -36,5 +36,5 @@ class WindowStringReader(object):

         self.window.set_action_panel(self.read_text)

         self.window.addstr(0, 0, self.display_string)

-    def get_user_string(self, params):

+    def get_user_string(self, params=None):

         return self.window.do_action()

@@ -43,7 +43,7 @@ def runInstaller(options, config):

     # Run the installer

     package_installer = Installer(config, rpm_path=options.rpm_path,

                                   log_path=options.log_path, log_level=options.log_level)

-    return package_installer.install(None)

+    return package_installer.install()

 def get_file_name_with_last_folder(filename):

     basename = os.path.basename(filename)

@@ -292,7 +292,6 @@ def createImage(options):

     if not success:

         raise Exception("Unexpected failure in creating disk, please check the logs")

         sys.exit(1)

-    config['vmdk_install'] = True

     result = runInstaller(options, config)

     process = subprocess.Popen([disk_cleanup_script, config['disk']['disk']])

     process.wait()