@@ -3,7 +3,6 @@

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

 import subprocess

-import curses

 import os

 import shutil

 import signal

@@ -34,7 +33,7 @@ class Installer(object):

         else:

             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:

@@ -62,7 +61,9 @@ class Installer(object):

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

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

-    def exit_gracefully(self, signal, frame):

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

@@ -73,8 +74,9 @@ class Installer(object):

         sys.exit(1)

     def install(self, params):

+        del params

         try:

-            return self.unsafe_install(params)

+            return self.unsafe_install()

         except Exception as inst:

             if self.iso_installer:

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

@@ -82,105 +84,13 @@ class Installer(object):

             else:

                 raise

-    def unsafe_install(self, params):

-

-        if self.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('/', '\/'))

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

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

-                retval = process.wait()

-                if retval != 0:

-                    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('/', '\/')))

-            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 unsafe_install(self):

+        self.setup_install_repo()

         self.execute_modules(modules.commons.PRE_INSTALL)

         self.initialize_system()

-

-        if self.iso_installer:

-            self.adjust_packages_for_vmware_virt()

-            selected_packages = self.install_config['packages']

-            state = 0

-            packages_to_install = {}

-            total_size = 0

-            with open(modules.commons.TDNF_CMDLINE_FILE_NAME, "w") as tdnf_cmdline_file:

-                tdnf_cmdline_file.write("tdnf install --installroot {0} --nogpgcheck {1}"

-                                        .format(self.photon_root, " ".join(selected_packages)))

-            with open(modules.commons.TDNF_LOG_FILE_NAME, "w") as tdnf_errlog:

-                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().decode()

-                    if output == '':

-                        retval = process.poll()

-                        if retval is not None:

-                            break

-                    if state == 0:

-                        if output == 'Installing:\n':

-                            state = 1

-                    elif state == 1: #N A EVR Size(readable) Size(in bytes)

-                        if output == '\n':

-                            state = 2

-                            self.progress_bar.update_num_items(total_size)

-                        else:

-                            info = output.split()

-                            package = '{0}-{1}.{2}'.format(info[0], info[2], info[1])

-                            packages_to_install[package] = int(info[5])

-                            total_size += int(info[5])

-                    elif state == 2:

-                        if output == 'Downloading:\n':

-                            self.progress_bar.update_message('Preparing ...')

-                            state = 3

-                    elif state == 3:

-                        self.progress_bar.update_message(output)

-                        if output == 'Running transaction\n':

-                            state = 4

-                    else:

-                        modules.commons.log(modules.commons.LOG_INFO, "[tdnf] {0}".format(output))

-                        prefix = 'Installing/Updating: '

-                        if output.startswith(prefix):

-                            package = output[len(prefix):].rstrip('\n')

-                            self.progress_bar.increment(packages_to_install[package])

-

-                        self.progress_bar.update_message(output)

-                # 0 : succeed; 137 : package already installed; 65 : package not found in repo.

-                if retval != 0 and retval != 137:

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

-                                        "Failed to install some packages, refer to {0}"

-                                        .format(modules.commons.TDNF_LOG_FILE_NAME))

-                    self.exit_gracefully(None, None)

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

-

-

-        if self.iso_installer:

-            self.progress_bar.show_loading('Finalizing installation')

-

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

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

+        self.install_packages()

+        self.enable_network_in_chroot()

         self.finalize_system()

         if not self.install_config['iso_system']:

@@ -228,9 +138,7 @@ class Installer(object):

             retval = process.wait()

             self.update_fstab()

-

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

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

+        self.disable_network_in_chroot()

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

         if not self.install_config['iso_system']:

@@ -240,17 +148,10 @@ class Installer(object):

         if self.iso_installer:

             self.progress_bar.hide()

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

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

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

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

-                process.wait()

+            self.eject_cdrom()

         return ActionResult(True, None)

     def copy_rpms(self):

@@ -263,7 +164,7 @@ class Installer(object):

         for pkg in selected_packages:

             if pkg in pkg_to_rpm_map:

-                if not pkg_to_rpm_map[pkg]['rpm'] is None:

+                if pkg_to_rpm_map[pkg]['rpm'] is not None:

                     name = pkg_to_rpm_map[pkg]['rpm']

                     basename = os.path.basename(name)

                     self.rpms_tobeinstalled.append({'filename': basename, 'path': name,

@@ -421,7 +322,7 @@ class Installer(object):

         rpms = set(rpm_file_names)

         rpm_paths = []

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

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

@@ -457,7 +358,7 @@ class Installer(object):

                 continue

             # the module default is disabled

-            if not hasattr(mod, 'enabled') or mod.enabled == False:

+            if not hasattr(mod, 'enabled') or mod.enabled is False:

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

                                     "module {} is not enabled".format(module))

                 continue

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

                                     "Error: not able to execute module {}".format(module))

                 continue

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

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

     def adjust_packages_for_vmware_virt(self):

         try:

@@ -492,3 +393,115 @@ class Installer(object):

                 selected_packages.append('linux-esx')

         except KeyError:

             pass

+

+    def setup_install_repo(self):

+        if self.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('/', '\/'))

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

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

+                retval = process.wait()

+                if retval != 0:

+                    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('/', '\/')))

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

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

+

+    def tdnf_install_packages(self):

+        self.adjust_packages_for_vmware_virt()

+        selected_packages = self.install_config['packages']

+        state = 0

+        packages_to_install = {}

+        total_size = 0

+        with open(modules.commons.TDNF_CMDLINE_FILE_NAME, "w") as tdnf_cmdline_file:

+            tdnf_cmdline_file.write("tdnf install --installroot {0} --nogpgcheck {1}"

+                                    .format(self.photon_root, " ".join(selected_packages)))

+        with open(modules.commons.TDNF_LOG_FILE_NAME, "w") as tdnf_errlog:

+            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().decode()

+                if output == '':

+                    retval = process.poll()

+                    if retval is not None:

+                        break

+                if state == 0:

+                    if output == 'Installing:\n':

+                        state = 1

+                elif state == 1: #N A EVR Size(readable) Size(in bytes)

+                    if output == '\n':

+                        state = 2

+                        self.progress_bar.update_num_items(total_size)

+                    else:

+                        info = output.split()

+                        package = '{0}-{1}.{2}'.format(info[0], info[2], info[1])

+                        packages_to_install[package] = int(info[5])

+                        total_size += int(info[5])

+                elif state == 2:

+                    if output == 'Downloading:\n':

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

+                        state = 3

+                elif state == 3:

+                    self.progress_bar.update_message(output)

+                    if output == 'Running transaction\n':

+                        state = 4

+                else:

+                    modules.commons.log(modules.commons.LOG_INFO, "[tdnf] {0}".format(output))

+                    prefix = 'Installing/Updating: '

+                    if output.startswith(prefix):

+                        package = output[len(prefix):].rstrip('\n')

+                        self.progress_bar.increment(packages_to_install[package])

+

+                    self.progress_bar.update_message(output)

+            # 0 : succeed; 137 : package already installed; 65 : package not found in repo.

+            if retval != 0 and retval != 137:

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

+                                    "Failed to install some packages, refer to {0}"

+                                    .format(modules.commons.TDNF_LOG_FILE_NAME))

+                self.exit_gracefully(None, None)

+        self.progress_bar.show_loading('Finalizing installation')

+

+    def eject_cdrom(self):

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

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

+            process.wait()

+

+    def enable_network_in_chroot(self):

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

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

+

+    def disable_network_in_chroot(self):

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

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

@@ -18,24 +18,35 @@ from license import License

 from linuxselector import LinuxSelector

 class IsoConfig(object):

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

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

+    def __init__(self):

         self.cd_path = None

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

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

+        self.hostname_accepted_chars = self.alpha_chars

+        # Adding the numeric chars

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

+        # Adding the . and -

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

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

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

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

         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:

+        if m is not None:

             rpm_path = m.group(1)

         else:

             # the rpms should be in the cd

-            self.mount_RPMS_cd()

+            self.mount_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:

+        if m is not None:

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

         install_config = None

@@ -45,21 +56,23 @@ class IsoConfig(object):

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

         return rpm_path, install_config

-    def is_vmware_virtualization(self):

+    @staticmethod

+    def is_vmware_virtualization():

+        """Detect vmware vm"""

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

         out, err = process.communicate()

         if err is not None and err != 0:

             return False

-        else:

-            return out == 'vmware\n'

+        return out == 'vmware\n'

     def get_config(self, path):

+        """kick start configuration"""

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

             # Do 5 trials to get the kick start

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

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

             wait = 1

-            for x in range(0, 5):

+            for _ in range(0, 5):

                 err_msg = ""

                 try:

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

@@ -70,9 +83,9 @@ class IsoConfig(object):

                     err_msg = e

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

-                    ks_file_error)

+                                    ks_file_error)

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

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

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

                 print(ks_file_error)

                 print("retry in a second")

                 time.sleep(wait)

@@ -84,11 +97,12 @@ class IsoConfig(object):

             raise Exception(err_msg)

         else:

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

-                self.mount_RPMS_cd()

+                self.mount_cd()

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

             return (JsonWrapper(path)).read()

-    def mount_RPMS_cd(self):

+    def mount_cd(self):

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

         # check if the cd is already mounted

         if self.cd_path:

             return

@@ -98,7 +112,7 @@ class IsoConfig(object):

         retval = process.wait()

         # Retry mount the CD

-        for i in range(0, 3):

+        for _ in range(0, 3):

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

             retval = process.wait()

             if retval == 0:

@@ -111,6 +125,8 @@ class IsoConfig(object):

         raise Exception("Can not mount the cd")

     def ks_config(self, options_file, ks_config):

+        """Load configuration from file"""

+        del options_file

         install_config = ks_config

         install_config['iso_system'] = False

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

@@ -123,7 +139,9 @@ class IsoConfig(object):

         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)

+        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

@@ -139,77 +157,103 @@ class IsoConfig(object):

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

+            install_config['hostname'] = "photon-" + self.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)]))

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

+    @staticmethod

+    def validate_hostname(hostname):

+        """A valid hostname must start with a letter"""

         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:

+        if hostname is None or not hostname:

             return False, error_empty

         fields = hostname.split('.')

         for field in fields:

-            if len(field) == 0:

+            if not field:

                 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

+        return (len(machinename) <= 64 and

+                machinename[0].isalpha(), error_hostname)

     @staticmethod

     def validate_password(text):

+        """Validate password with cracklib"""

         try:

-            p = cracklib.VeryFascistCheck(text)

+            password = cracklib.VeryFascistCheck(text)

         except ValueError as message:

-            p = str(message)

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

+            password = str(message)

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

     @staticmethod

     def generate_password_hash(password):

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

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

+        shadow_password = crypt.crypt(

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

+                [random.choice(

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

         return shadow_password

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

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

+        """Configuration through UI"""

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

+        # I can go back to this window or not

         install_config = {'iso_system': False}

         install_config['ui_install'] = True

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

+                                                      install_config)

+        index = 0

+        while True:

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

+            if result.success:

+                index += 1

+                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

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

+        items = []

         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

+            self.hostname_accepted_chars, # set of accepted chars

+            IsoConfig.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,

+            self.random_hostname,

             True)

         root_password_reader = WindowStringReader(

             maxy, maxx, 10, 70,

@@ -223,7 +267,8 @@ class IsoConfig(object):

         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

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

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

             '*', # echo char

             None, # set of accepted chars

             None, # validation function of the input

@@ -243,27 +288,4 @@ class IsoConfig(object):

         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

+        return items, select_linux_index

@@ -6,8 +6,8 @@ PRE_INSTALL = "pre-install"

 POST_INSTALL = "post-install"

 LOG_LEVEL_DESC = ["emerg", "alert", "crit", "err", "warning", "notice", "info", "debug"]

-LOG_FILE_NAME  = "/var/log/installer.log"

-TDNF_LOG_FILE_NAME  = "/var/log/tdnf.log"

+LOG_FILE_NAME = "/var/log/installer.log"

+TDNF_LOG_FILE_NAME = "/var/log/tdnf.log"

 TDNF_CMDLINE_FILE_NAME = "/var/log/tdnf.cmdline"

 KS_POST_INSTALL_LOG_FILE_NAME = "/var/log/installer-kickstart.log"

 SIGNATURE   = "localhost echo"

@@ -21,8 +21,8 @@ LOG_INFO    = 6

 LOG_DEBUG   = 7

 default_partitions = [

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

-                     ]

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

+    ]

 def partition_compare(p):

     if 'mountpoint' in p:

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

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

     # Clear the disk

-    process = subprocess.Popen(['sgdisk', '-o', '-g', disk], stderr = output, stdout = output)

+    process = subprocess.Popen(['sgdisk', '-o', '-g', disk], stderr=output, stdout=output)

     retval = process.wait()

     if retval != 0:

         log(LOG_ERROR, "Failed clearing disk {0}".format(disk))

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

     # Adding the known size partitions

     for partition in partitions:

         if partition['size'] == 0:

-            # Can not have more than 1 extensible partition 

+            # Can not have more than 1 extensible partition

             if extensible_partition != None:

                 log(LOG_ERROR, "Can not have more than 1 extensible partition")

                 return None

@@ -80,13 +80,13 @@ def partition_disk(disk, partitions):

     partition_cmd.extend(['-p', disk])

     # Run the partitioning command

-    process = subprocess.Popen(partition_cmd, stderr = output, stdout = output)

+    process = subprocess.Popen(partition_cmd, stderr=output, stdout=output)

     retval = process.wait()

     if retval != 0:

         log(LOG_ERROR, "Faild partition disk, command: {0}". format(partition_cmd))

         return None

-    process = subprocess.Popen(['sgdisk', '-t1' + grub_flag, disk], stderr = output, stdout = output)

+    process = subprocess.Popen(['sgdisk', '-t1' + grub_flag, disk], stderr=output, stdout=output)

     retval = process.wait()

     if retval != 0:

         log(LOG_ERROR, "Failed to setup grub partition")

@@ -103,25 +103,27 @@ def partition_disk(disk, partitions):

                 partitions_data['boot_partition_number'] = partition['partition_number']

                 partitions_data['bootdirectory'] = '/'

         if partition['filesystem'] == "swap":

-            process = subprocess.Popen(['mkswap', partition['path']], stderr = output, stdout = output)

+            process = subprocess.Popen(['mkswap', partition['path']], stderr=output, stdout=output)

             retval = process.wait()

             if retval != 0:

                 log(LOG_ERROR, "Failed to create swap partition @ {}".format(partition['path']))

                 return None

         else:

             mkfs_cmd = ['mkfs', '-t', partition['filesystem'], partition['path']]

-            process = subprocess.Popen(mkfs_cmd, stderr = output, stdout = output)

+            process = subprocess.Popen(mkfs_cmd, stderr=output, stdout=output)

             retval = process.wait()

             if retval != 0:

-                log(LOG_ERROR, "Failed to format {} partition @ {}".format(partition['filesystem'], partition['path']))

+                log(LOG_ERROR,

+                    "Failed to format {} partition @ {}".format(partition['filesystem'],

+                                                                partition['path']))

                 return None

     # Check if there is no root partition

-    if not 'root' in partitions_data:

+    if 'root' not in partitions_data:

         log(LOG_ERROR, "There is no partition assigned to root '/'")

         return None

-    if not 'boot' in partitions_data:

+    if 'boot' not in partitions_data:

         partitions_data['boot'] = partitions_data['root']

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

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

@@ -130,9 +132,9 @@ def partition_disk(disk, partitions):

     return partitions_data

-def replace_string_in_file(filename,  search_string,  replace_string):

+def replace_string_in_file(filename, search_string, replace_string):

     with open(filename, "r") as source:

-        lines=source.readlines()

+        lines = source.readlines()

     with open(filename, "w") as destination:

         for line in lines:

@@ -145,7 +147,8 @@ def log(type, message):

     return retval

 def dump(type, filename):

-    command = "journalctl -p {0} | grep --line-buffered \"{1}\" > {2}".format(LOG_LEVEL_DESC[type], SIGNATURE, filename)

+    command = ("journalctl -p {0} | grep --line-buffered \"{1}\" > {2}"

+               .format(LOG_LEVEL_DESC[type], SIGNATURE, filename))

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

     retval = process.wait()

     return retval

@@ -153,5 +156,5 @@ def dump(type, filename):

 def dump(filename):

     command = "journalctl | grep --line-buffered \"{0}\" > {1}".format(SIGNATURE, filename)

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

-    retval = process.wait()    

+    retval = process.wait()

     return retval

@@ -5,7 +5,7 @@ import commons

 install_phase = commons.POST_INSTALL

 enabled = True

-def execute(name, config, root):

+def execute(config, root):

     if 'postinstall' not in config:

         return

     # run the script in the chroot environment

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

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

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

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

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

-    os.chmod(script_file, 0o700);

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

-        process = subprocess.Popen(["./mk-run-chroot.sh", '-w', root, "/etc/tmpfiles.d/postinstall.sh"],

-            stdout=logfile,stderr=logfile)

+    os.chmod(script_file, 0o700)

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

+        process = subprocess.Popen(["./mk-run-chroot.sh", '-w', root,

+                                    "/etc/tmpfiles.d/postinstall.sh"],

+                                   stdout=logfile, stderr=logfile)

         retval = process.wait()

-        if retval==0:

+        if retval == 0:

             return True

         return False

@@ -1,11 +1,11 @@

 import os

-import commons

 import random

+import commons

 install_phase = commons.POST_INSTALL

 enabled = True

-def execute(name, config, root):

+def execute(config, root):

     hostname = config['hostname']

     hostname_file = os.path.join(root, 'etc/hostname')

@@ -1,26 +1,25 @@

 import os

-import commons

 import crypt

 import random

 import string

+import commons

 install_phase = commons.POST_INSTALL

 enabled = True

-def execute(name, config, root):

+def execute(config, root):

     shadow_password = config['password']

     passwd_filename = os.path.join(root, 'etc/passwd')

     shadow_filename = os.path.join(root, 'etc/shadow')

-    

+

     #replace root blank password in passwd file to point to shadow file

-    commons.replace_string_in_file(passwd_filename,  "root::", "root:x:")

+    commons.replace_string_in_file(passwd_filename, "root::", "root:x:")

     if os.path.isfile(shadow_filename) == False:

         with open(shadow_filename, "w") as destination:

-            destination.write("root:"+shadow_password+":")

+            destination.write("root:" + shadow_password + ":")

     else:

         #add password hash in shadow file

         commons.replace_string_in_file(shadow_filename, "root::", "root:"+shadow_password+":")

         commons.replace_string_in_file(shadow_filename, "root:x:", "root:"+shadow_password+":")

-

@@ -5,7 +5,7 @@ import commons

 install_phase = commons.POST_INSTALL

 enabled = True

-def execute(name, config, root):

+def execute(config, root):

     if 'public_key' not in config:

         return

@@ -21,5 +21,6 @@ def execute(name, config, root):

     os.chmod(authorized_keys_filename, 0o600)

     # Change the sshd config to allow root login

-    process = subprocess.Popen(["sed", "-i", "s/^\\s*PermitRootLogin\s\+no/PermitRootLogin yes/", sshd_config_filename])

+    process = subprocess.Popen(["sed", "-i", "s/^\\s*PermitRootLogin\s\+no/PermitRootLogin yes/",

+                                sshd_config_filename])

     return process.wait()