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

 {   

     "packages": ["glibc","zlib","filesystem","file","gmp","libgcc","libstdc++","bash","sed",

-                  "bzip2","pkg-config","ncurses","ncurses-compat","cracklib","cracklib-dicts","cracklib-python",

+                  "bzip2","pkg-config","python3-curses","ncurses", "cracklib","cracklib-dicts","python3-cracklib",

                   "shadow","coreutils","grep","readline","findutils","xz","util-linux","e2fsprogs",

                   "libffi","expat","linux","cpio","Linux-PAM","attr","libcap", "systemd","dbus",

                   "gzip", "sqlite","nspr","nss","popt","lua","rpm","gptfdisk","tar", "librepo",

-                  "hawkey", "python2","python2-libs","pcre","glib", "tdnf", "python-requests",

+                  "hawkey", "python3","python3-libs","pcre","glib", "tdnf", "python3-requests",

                   "grub2-pc", "grub2-efi", "dracut", "curl", "ostree", "dosfstools"]

 }

@@ -19,7 +19,7 @@ class ConfirmWindow(Window):

                         ('No',  self.exit_function, False)

                     ]

         self.menu = Menu(menu_starty,  maxx, items, can_navigate_outside = False, horizontal=True)

-        super(ConfirmWindow, self).__init__(height, width, maxy, maxx, 'Confirm', False, self.menu, items=[])

+        super(ConfirmWindow, self).__init__(height, width, maxy, maxx, 'Confirm', False, self.menu)

         self.addstr(0,0, message)

     def exit_function(self, yes):

@@ -29,15 +29,16 @@ class Device(object):

         for deviceline in deviceslines:

             cols = deviceline.split(None, 2)

             #skip Virtual NVDIMM from install list

-            if(cols[0].startswith("pmem")):

+            colstr = cols[0].decode()

+            if(colstr.startswith("pmem")):

                 continue

             model = "Unknown"

             if(len(cols) >= 3):

-                model = cols[2]

+                model = cols[2].decode()

             devices.append(

                     Device(model #Model

-                        , '/dev/' + cols[0] #Path

-                        , cols[1] #size

+                        , '/dev/' + cols[0].decode() #Path

+                        , cols[1].decode() #size

                         ))

-        return devices

\ No newline at end of file

+        return devices

@@ -53,7 +53,7 @@ class Installer(object):

             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, 'Installing Photon', False, items =[])

+            self.window = Window(self.height, self.width, self.maxy, self.maxx, 'Installing Photon', False)

             self.progress_bar = ProgressBar(self.starty + 3, self.startx + self.progress_padding // 2, self.progress_width)

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

@@ -115,7 +115,7 @@ class Installer(object):

                 process = subprocess.Popen(

                     ['tdnf', 'install'] + selected_packages + ['--installroot', self.photon_root, '--nogpgcheck', '--assumeyes'], stdout=subprocess.PIPE, stderr=tdnf_errlog)

                 while True:

-                    output = process.stdout.readline()

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

                     if output == '':

                         retval = process.poll()

                         if retval is not None:

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

         return process.wait()

     def execute_modules(self, phase):

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

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

         for mod_path in modules_paths:

             module = mod_path.replace('/', '.', 1)

@@ -429,6 +430,7 @@ class Installer(object):

             if not hasattr(mod, 'execute'):

                 modules.commons.log(modules.commons.LOG_ERROR, "Error: not able to execute module {}".format(module))

                 continue

+

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

     def adjust_packages_for_vmware_virt(self):

@@ -446,18 +448,3 @@ class Installer(object):

                 selected_packages.append('linux-esx')

         except KeyError:

             pass

-

-    def run(self, command, comment = None):

-        if comment != None:

-            modules.commons.log(modules.commons.LOG_INFO, "Installer: {} ".format(comment))

-            self.progress_bar.update_loading_message(comment)

-

-        modules.commons.log(modules.commons.LOG_INFO, "Installer: {} ".format(command))

-        process = subprocess.Popen([command], shell=True, stdout=subprocess.PIPE)

-        out,err = process.communicate()

-        if err != None and err != 0 and "systemd-tmpfiles" not in command:

-            modules.commons.log(modules.commons.LOG_ERROR, "Installer: failed in {} with error code {}".format(command, err))

-            modules.commons.log(modules.commons.LOG_ERROR, out)

-            self.exit_gracefully(None, None)

-

-        return err

@@ -1,298 +1,15 @@

-#! /usr/bin/python2

+#! /usr/bin/python3

 #

 #    Copyright (C) 2015 vmware inc.

 #

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

 from argparse import ArgumentParser

-import os.path

 import curses

-import subprocess

-import re

-import json

-import time

-import crypt

-import string

-import random

-import urllib2

-import requests

-import cracklib

-import modules.commons

-from partitionISO import PartitionISO

-from packageselector import PackageSelector

-from installer import Installer

 from installercontainer import InstallerContainer

-from windowstringreader import WindowStringReader

-from jsonwrapper import JsonWrapper

-from selectdisk import SelectDisk

-from license import License

-from linuxselector import LinuxSelector

+from iso_config import IsoConfig

 class IsoInstaller(object):

-

-    def get_config(self, path):

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

-

-                modules.commons.log(modules.commons.LOG_ERROR,

-                    ks_file_error)

-                modules.commons.log(modules.commons.LOG_ERROR,

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

-                print(ks_file_error)

-                print("retry in a second")

-                time.sleep(wait)

-                wait = wait * 2

-

-            # Something went wrong

-            print(ks_file_error)

-            print("exiting the installer, check the logs for more details")

-            raise Exception(err_msg)

-        else:

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

-                self.mount_RPMS_cd()

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

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

-

-    def mount_RPMS_cd(self):

-        # check if the cd is already mounted

-        if self.cd_path:

-            return

-

-        # Mount the cd to get the RPMS

-        process = subprocess.Popen(['mkdir', '-p', '/mnt/cdrom'])

-        retval = process.wait()

-

-        # Retry mount the CD

-        for i in range(0, 3):

-            process = subprocess.Popen(['mount', '/dev/cdrom', '/mnt/cdrom'])

-            retval = process.wait()

-            if retval == 0:

-                self.cd_path = "/mnt/cdrom"

-                return

-            print("Failed to mount the cd, retry in a second")

-            time.sleep(1)

-        print("Failed to mount the cd, exiting the installer")

-        print("check the logs for more details")

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

-

-    def validate_hostname(self, hostname):

-        error_empty = "Empty hostname or domain is not allowed"

-        error_dash = "Hostname or domain should not start or end with '-'"

-        error_hostname = "Hostname should start with alpha char and <= 64 chars"

-

-        if hostname is None or len(hostname) == 0:

-            return False, error_empty

-

-        fields = hostname.split('.')

-        for field in fields:

-            if len(field) == 0:

-                return False, error_empty

-            if field[0] == '-' or field[-1] == '-':

-                return False, error_dash

-

-        machinename = fields[0]

-        return (len(machinename) <= 64) and (ord(machinename[0]) in self.alpha_chars), error_hostname

-

-    @staticmethod

-    def validate_password(text):

-        try:

-            p = cracklib.VeryFascistCheck(text)

-        except ValueError as message:

-            p = str(message)

-        return p == text, "Error: " + p

-

-    @staticmethod

-    def generate_password_hash(password):

-        shadow_password = crypt.crypt(password, "$6$" + "".join([random.choice(string.ascii_letters + string.digits) for _ in range(16)]))

-        return shadow_password

-

-    def validate_http_response(self, url, checks, exception_text, error_text):

-        try:

-            if url.startswith("https"):

-                response = urllib2.urlopen(url, cafile="/usr/lib/python2.7/site-packages/requests/cacert.pem")

-            else:

-                response = urllib2.urlopen(url)

-

-        except:

-            return exception_text

-        else:

-            if response.getcode() != 200:

-                return error_text

-

-        html = response.read()

-

-        for pattern, count, failed_check_text in checks:

-            match = re.findall(pattern, html)

-            if len(match) != count:

-                return failed_check_text

-

-        return ""

-    def ui_install(self, options_file, rpm_path):

-        # This represents the installer screen, the bool indicated if I can go back to this window or not

-        items = []

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

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

-        install_config = {'iso_system': False}

-        install_config['ui_install'] = True

-        license_agreement = License(self.maxy, self.maxx)

-        select_disk = SelectDisk(self.maxy, self.maxx, install_config)

-        select_partition = PartitionISO(self.maxy, self.maxx, install_config)

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

-        self.alpha_chars = range(65, 91)

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

-        hostname_accepted_chars = list(self.alpha_chars)

-        # Adding the numeric chars

-        hostname_accepted_chars.extend(range(48, 58))

-        # Adding the . and -

-        hostname_accepted_chars.extend([ord('.'), ord('-')])

-

-        hostname_reader = WindowStringReader(

-            self.maxy, self.maxx, 10, 70,

-            'hostname',

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

-            None, # echo char

-            hostname_accepted_chars, # set of accepted chars

-            self.validate_hostname, # validation function of the input

-            None, # post processing of the input field

-            'Choose the hostname for your system', 'Hostname:', 2, install_config,

-            random_hostname,

-            True)

-        root_password_reader = WindowStringReader(

-            self.maxy, self.maxx, 10, 70,

-            'password',

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

-            '*', # echo char

-            None, # set of accepted chars

-            IsoInstaller.validate_password, # validation function of the input

-            None,  # post processing of the input field

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

-        confirm_password_reader = WindowStringReader(

-            self.maxy, self.maxx, 10, 70,

-            'password',

-            "Passwords don't match, please try again.", # confirmation error msg if it's a confirmation text

-            '*', # echo char

-            None, # set of accepted chars

-            None, # validation function of the input

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

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

-

-        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(self.maxy, self.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))

-        installer = InstallerContainer(

-            install_config,

-            self.maxy,

-            self.maxx,

-            True,

-            rpm_path=rpm_path,

-            log_path="/var/log")

-

-        items = items + [(installer.install, False)]

-

-        index = 0

-        params = None

-        while True:

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

-            if result.success:

-                index += 1

-                params = result.result

-                if index == len(items) - 1:

-                    self.screen.clear()

-                if index == len(items):

-                    break

-                #Skip linux select screen for ostree installation.

-                if index == select_linux_index:

-                    if install_config['type'] == 'ostree_server':

-                        index += 1

-            else:

-                index -= 1

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

-                    index -= 1

-                if index < 0:

-                    index = 0

-                #Skip linux select screen for ostree installation.

-                if index == select_linux_index:

-                    if install_config['type'] == 'ostree_server':

-                        index -= 1

-

-    def ks_install(self, options_file, rpm_path, ks_config):

-        install_config = ks_config

-        install_config['iso_system'] = False

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

-            install_config['install_linux_esx'] = True

-

-        json_wrapper_option_list = JsonWrapper("build_install_options_all.json")

-        option_list_json = json_wrapper_option_list.read()

-        options_sorted = option_list_json.items()

-

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

-        package_list = []

-

-        package_list = PackageSelector.get_packages_to_install(options_sorted, install_config['type'], base_path)

-        if 'additional_packages' in install_config:

-            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'] == "":

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

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

-

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

-

-        installer = InstallerContainer(

-            install_config,

-            self.maxy, self.maxx,

-            True,

-            rpm_path=rpm_path,

-            log_path="/var/log")

-

-        installer.install(None)

-

-    def is_vmware_virtualization(self):

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

-        out, err = process.communicate()

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

-            return False

-        else:

-            return out == 'vmware\n'

-

     def __init__(self, stdscreen, options_file):

         self.screen = stdscreen

@@ -307,35 +24,22 @@ 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, self.maxy, self.maxx)

-        self.cd_path = None

-

-        kernel_params = subprocess.check_output(['cat', '/proc/cmdline'])

-

-        # check the kickstart param

-        ks_config = None

-        m = re.match(r".*ks=(\S+)\s*.*\s*", kernel_params)

-        if m != None:

-            ks_config = self.get_config(m.group(1))

-

-        # check for the repo param

-        m = re.match(r".*repo=(\S+)\s*.*\s*", kernel_params)

-        if m != None:

-            rpm_path = m.group(1)

-        else:

-            # the rpms should be in the cd

-            self.mount_RPMS_cd()

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

+        self.screen.clear()

+        installer = InstallerContainer(

+            install_config,

+            self.maxy, self.maxx,

+            True,

+            rpm_path=rpm_path,

+            log_path="/var/log")

-        if ks_config:

-            self.ks_install(options_file, rpm_path, ks_config)

-        else:

-            self.ui_install(options_file, rpm_path)

+        installer.install(None)

 if __name__ == '__main__':

     usage = "Usage: %prog [options]"

     parser = ArgumentParser(usage)

     parser.add_argument("-j", "--json-file", dest="options_file", default="input.json")

-

     options = parser.parse_args()

     curses.wrapper(IsoInstaller, options.options_file)

new file mode 100644

@@ -0,0 +1,269 @@

+import os.path

+import subprocess

+import re

+import json

+import time

+import crypt

+import string

+import random

+import requests

+import cracklib

+import modules.commons

+from partitionISO import PartitionISO

+from packageselector import PackageSelector

+from windowstringreader import WindowStringReader

+from jsonwrapper import JsonWrapper

+from selectdisk import SelectDisk

+from license import License

+from linuxselector import LinuxSelector

+

+class IsoConfig(object):

+    def Configure(self,options_file, maxy, maxx):

+        self.cd_path = None

+

+        kernel_params = subprocess.check_output(['cat', '/proc/cmdline'])

+

+        # check for the repo param

+        m = re.match(r".*repo=(\S+)\s*.*\s*", kernel_params.decode())

+        if m != None:

+            rpm_path = m.group(1)

+        else:

+            # the rpms should be in the cd

+            self.mount_RPMS_cd()

+            rpm_path = os.path.join(self.cd_path, "RPMS")

+

+        # check the kickstart param

+        ks_config = None

+        m = re.match(r".*ks=(\S+)\s*.*\s*", kernel_params.decode())

+        if m != None:

+            ks_config = self.get_config(m.group(1))

+

+        install_config = None

+        if ks_config:

+            install_config = self.ks_config(options_file, ks_config)

+        else:

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

+        return rpm_path, install_config

+

+    def is_vmware_virtualization(self):

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

+        out, err = process.communicate()

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

+            return False

+        else:

+            return out == 'vmware\n'

+

+    def get_config(self, path):

+        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 x 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

+

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

+                    ks_file_error)

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

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

+                print(ks_file_error)

+                print("retry in a second")

+                time.sleep(wait)

+                wait = wait * 2

+

+            # Something went wrong

+            print(ks_file_error)

+            print("exiting the installer, check the logs for more details")

+            raise Exception(err_msg)

+        else:

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

+                self.mount_RPMS_cd()

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

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

+

+    def mount_RPMS_cd(self):

+        # check if the cd is already mounted

+        if self.cd_path:

+            return

+

+        # Mount the cd to get the RPMS

+        process = subprocess.Popen(['mkdir', '-p', '/mnt/cdrom'])

+        retval = process.wait()

+

+        # Retry mount the CD

+        for i in range(0, 3):

+            process = subprocess.Popen(['mount', '/dev/cdrom', '/mnt/cdrom'])

+            retval = process.wait()

+            if retval == 0:

+                self.cd_path = "/mnt/cdrom"

+                return

+            print("Failed to mount the cd, retry in a second")

+            time.sleep(1)

+        print("Failed to mount the cd, exiting the installer")

+        print("check the logs for more details")

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

+

+    def ks_config(self, options_file, ks_config):

+        install_config = ks_config

+        install_config['iso_system'] = False

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

+            install_config['install_linux_esx'] = True

+

+        json_wrapper_option_list = JsonWrapper("build_install_options_all.json")

+        option_list_json = json_wrapper_option_list.read()

+        options_sorted = option_list_json.items()

+

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

+        package_list = []

+

+        package_list = PackageSelector.get_packages_to_install(options_sorted, install_config['type'], base_path)

+        if 'additional_packages' in install_config:

+            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'] == "":

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

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

+

+        # 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

+

+    def validate_hostname(self, hostname):

+        error_empty = "Empty hostname or domain is not allowed"

+        error_dash = "Hostname or domain should not start or end with '-'"

+        error_hostname = "Hostname should start with alpha char and <= 64 chars"

+

+        if hostname is None or len(hostname) == 0:

+            return False, error_empty

+

+        fields = hostname.split('.')

+        for field in fields:

+            if len(field) == 0:

+                return False, error_empty

+            if field[0] == '-' or field[-1] == '-':

+                return False, error_dash

+

+        machinename = fields[0]

+        return (len(machinename) <= 64) and (ord(machinename[0]) in self.alpha_chars), error_hostname

+

+    @staticmethod

+    def validate_password(text):

+        try:

+            p = cracklib.VeryFascistCheck(text)

+        except ValueError as message:

+            p = str(message)

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

+

+    @staticmethod

+    def generate_password_hash(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):

+        # This represents the installer screen, the bool indicated if I can go back to this window or not

+        items = []

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

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

+        install_config = {'iso_system': False}

+        install_config['ui_install'] = True

+        license_agreement = License(maxy, maxx)

+        select_disk = SelectDisk(maxy, maxx, install_config)

+        select_partition = PartitionISO(maxy, maxx, install_config)

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

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

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

+        hostname_accepted_chars = self.alpha_chars

+        # Adding the numeric chars

+        hostname_accepted_chars.extend(range(48, 58))

+        # Adding the . and -

+        hostname_accepted_chars.extend([ord('.'), ord('-')])

+

+        hostname_reader = WindowStringReader(

+            maxy, maxx, 10, 70,

+            'hostname',

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

+            None, # echo char

+            hostname_accepted_chars, # set of accepted chars

+            self.validate_hostname, # validation function of the input

+            None, # post processing of the input field

+            'Choose the hostname for your system', 'Hostname:', 2, install_config,

+            random_hostname,

+            True)

+        root_password_reader = WindowStringReader(

+            maxy, maxx, 10, 70,

+            'password',

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

+            '*', # echo char

+            None, # set of accepted chars

+            IsoConfig.validate_password, # validation function of the input

+            None,  # post processing of the input field

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

+        confirm_password_reader = WindowStringReader(

+            maxy, maxx, 10, 70,

+            'password',

+            "Passwords don't match, please try again.", # confirmation error msg if it's a confirmation text

+            '*', # echo char

+            None, # set of accepted chars

+            None, # validation function of the input

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

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

+

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

+        index = 0

+        params = None

+        while True:

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

+            if result.success:

+                index += 1

+                params = result.result

+                if index == len(items):

+                    break

+                #Skip linux select screen for ostree installation.

+                if index == select_linux_index:

+                    if install_config['type'] == 'ostree_server':

+                        index += 1

+            else:

+                index -= 1

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

+                    index -= 1

+                if index < 0:

+                    index = 0

+                #Skip linux select screen for ostree installation.

+                if index == select_linux_index:

+                    if install_config['type'] == 'ostree_server':

+                        index -= 1

+        return install_config

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

         self.text_height = self.win_height - 6

         self.text_width = self.win_width - 6

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', False, items=[])

+        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', False)

     def display(self, params):

         accept_decline_items =  [

@@ -15,8 +15,8 @@ class LinuxSelector(object):

         self.win_width = 60

         self.win_height = 13

-        self.win_starty = (self.maxy - self.win_height) / 2

-        self.win_startx = (self.maxx - self.win_width) / 2

+        self.win_starty = (self.maxy - self.win_height) // 2

+        self.win_startx = (self.maxx - self.win_width) // 2

         self.menu_starty = self.win_starty + 6

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

                               default_selected=0, tab_enable=False)

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

-                             'Select Linux kernel to install', True, items=[], tab_enabled=False,

+                             'Select Linux kernel to install', True, tab_enabled=False,

                              position=1, can_go_next=True)

         self.window.set_action_panel(self.host_menu)

@@ -126,7 +126,7 @@ if [ "$LIVE_CD" = false ] ; then

 cat >> ${BUILDROOT}/bin/bootphotoninstaller << EOF

 #!/bin/bash

 cd /installer

-[ \`tty\` == '/dev/tty1' ] && ./isoInstaller.py --json-file=$PACKAGE_LIST_FILE_BASE_NAME 2> /var/log/installer && shutdown -r now

+[ \$(tty) == '/dev/tty1' ] && LANG=en_US.UTF-8 ./isoInstaller.py --json-file=$PACKAGE_LIST_FILE_BASE_NAME 2> /var/log/installer && shutdown -r now

 /bin/bash

 EOF

@@ -24,12 +24,10 @@ default_partitions = [

                         {"mountpoint": "/", "size": 0, "filesystem": "ext4"},

                      ]

-def partition_compare(p1, p2):

-    if 'mountpoint' in p1 and 'mountpoint' in p2:

-        if len(p1['mountpoint']) == len(p2['mountpoint']):

-            return cmp(p1['mountpoint'], p2['mountpoint'])

-        return len(p1['mountpoint']) - len(p2['mountpoint'])

-    return 0

+def partition_compare(p):

+    if 'mountpoint' in p:

+        return (1, len(p['mountpoint']), p['mountpoint'])

+    return (0, 0, "A")

 def partition_disk(disk, partitions):

     partitions_data = {}

@@ -128,7 +126,7 @@ def partition_disk(disk, partitions):

         partitions_data['boot_partition_number'] = partitions_data['root_partition_number']

         partitions_data['bootdirectory'] = '/boot/'

-    partitions.sort(lambda p1,p2: partition_compare(p1, p2))

+    partitions.sort(key=lambda p: partition_compare(p))

     return partitions_data

@@ -14,7 +14,7 @@ def execute(name, config, root):

     script_file = os.path.join(root, 'etc/tmpfiles.d/postinstall.sh')

     with open(script_file,  'wb') as outfile:

-        outfile.write("\n".join(script))

+        outfile.write("\n".join(script).encode())

     os.chmod(script_file, 0o700);

     with open(commons.KS_POST_INSTALL_LOG_FILE_NAME,"w") as logfile:

@@ -12,6 +12,8 @@ def execute(name, config, root):

     hosts_file    = os.path.join(root, 'etc/hosts')

     with open(hostname_file, 'wb') as outfile:

-        outfile.write(hostname)

+        outfile.write(hostname.encode())

-    commons.replace_string_in_file(hosts_file, r'127\.0\.0\.1\s+localhost\s*\Z', '127.0.0.1\tlocalhost\n127.0.0.1\t' + hostname)

+    pattern = r'(127\.0\.0\.1)(\s+)(localhost)\s*\Z'

+    replace = r'\1\2\3\n\1\2' + hostname

+    commons.replace_string_in_file(hosts_file, pattern, replace)

@@ -15,8 +15,8 @@ class PartitionISO(object):

         self.install_config = install_config

         self.path_checker = []

-        self.win_starty = (self.maxy - self.win_height) / 2

-        self.win_startx = (self.maxx - self.win_width) / 2

+        self.win_starty = (self.maxy - self.win_height) // 2

+        self.win_startx = (self.maxx - self.win_width) // 2

         self.text_starty = self.win_starty + 4

         self.text_height = self.win_height - 6

@@ -29,9 +29,9 @@ class PartitionISO(object):

         self.disk_size = []

         for index, device in enumerate(self.devices):

-            self.disk_size.append((device.path, int(device.size) / 1048576))     

+            self.disk_size.append((device.path, int(device.size) / 1048576))

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', False, items=[], can_go_next=False)

+        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', False, can_go_next=False)

         Device.refresh_devices()

     def display(self, params):

@@ -60,7 +60,7 @@ class PartitionISO(object):

         self.table_space = 5

         title = 'Current partitions:\n'

-        self.window.addstr(0, (self.win_width - len(title)) / 2, title)

+        self.window.addstr(0, (self.win_width - len(title)) // 2, title)

         info = "Unpartitioned space: "+str(self.disk_size[self.device_index][1])+ " MB, Total size: "+ str(int(self.devices[self.device_index].size)/ 1048576)+" MB"

@@ -163,7 +163,7 @@ class PartitionISO(object):

         if self.install_config['partitionsnumber'] == 0:

             window_height=9

             window_width=40

-            window_starty=(self.maxy-window_height)/2+5

+            window_starty=(self.maxy-window_height) // 2+5

             confirm_window=ConfirmWindow(window_height,window_width,self.maxy, self.maxx, window_starty, 'Partition information cannot be empty', info=True)

             confirm_window.do_action()

             return self.display(False)

@@ -171,7 +171,7 @@ class PartitionISO(object):

         if not self.has_slash:

             window_height=9

             window_width=40

-            window_starty=(self.maxy-window_height)/2+5

+            window_starty=(self.maxy-window_height) // 2 + 5

             confirm_window=ConfirmWindow(window_height,window_width,self.maxy, self.maxx, window_starty, 'Missing /', info=True)

             confirm_window.do_action()

             return self.display(False)

@@ -27,7 +27,7 @@ class ReadMulText(Action):

         self.default_string = default_string

         self.display_string = display_string

         self.textwin_width = maxx - self.horizontal_padding -2

-        self.textwin_width = self.textwin_width*2/3

+        self.textwin_width = self.textwin_width* 2 // 3

         self.visible_text_width = self.textwin_width - 1

         self.position = 0

         self.height = len(self.display_string) * 4 + 2

@@ -41,10 +41,10 @@ class ReadMulText(Action):

         self.shadowwin.bkgd(' ', curses.color_pair(0)) #Default shadow color

         self.panel = curses.panel.new_panel(self.textwin)

-        self.panel.move((maxy-self.height)/2, (maxx - self.textwin_width) / 2 -1)

+        self.panel.move((maxy-self.height) // 2, (maxx - self.textwin_width) // 2 -1)

         self.panel.hide()

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