deleted file mode 100644

@@ -1,58 +0,0 @@

-#!/usr/bin/python2

-#

-#    Copyright (C) 2015 vmware inc.

-#

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

-

-import json

-import curses

-from sets import Set

-from jsonwrapper import JsonWrapper

-from menu import Menu

-from window import Window

-from actionresult import ActionResult

-

-class CustomPackageSelector(object):

-    def __init__(self,  maxy, maxx, install_config):

-        self.install_config = install_config

-        self.menu_items = []

-

-        self.maxx = maxx

-        self.maxy = maxy

-        self.win_width = 60

-        self.win_height = 23

-

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

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

-

-        self.menu_starty = self.win_starty + 3

-        self.selected_packages = Set([])

-

-        self.load_package_list()

-

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Select your Packages', True, self.package_menu)

-

-    def load_package_list(self):

-        json_wrapper_package_list = JsonWrapper("packages_full.json");

-        package_list_json = json_wrapper_package_list.read()

-

-        for package in package_list_json["packages"]:

-            self.menu_items.append((package, self.exit_function))

-        self.package_menu = Menu(self.menu_starty,  self.maxx, self.menu_items, height = 18, selector_menu = True)

-

-

-    def exit_function(self,  selected_indexes):

-        json_wrapper_package_list = JsonWrapper("packages_minimal.json");

-        package_list_json = json_wrapper_package_list.read()

-        selected_items = []

-        for index in selected_indexes:

-            selected_items.append(self.menu_items[index][0])

-

-        self.install_config['packages'] = package_list_json["packages"] + selected_items

-        return ActionResult(True, None)

-

-    def display(self, params):

-        if (params['custom']):

-            return self.window.do_action()

-        else:

-            return ActionResult(True, None)

deleted file mode 100755

@@ -1,51 +0,0 @@

-#! /usr/bin/python2

-#

-#    Copyright (C) 2015 vmware inc.

-#

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

-

-import subprocess

-import os

-import json

-from device import Device

-from menu import Menu

-from window import Window

-from actionresult import ActionResult

-

-class DiskPartitioner(object):

-    def __init__(self,  maxy, maxx):

-        self.menu_items = []

-

-        self.maxx = maxx

-        self.maxy = maxy

-        self.win_width = 70

-        self.win_height = 17

-

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

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

-

-        self.menu_starty = self.win_starty + 10

-

-        # initialize the devices

-        self.devices = Device.refresh_devices()

-

-        self.items =   [

-                            ('Auto-partitioning - use entire disk',  self.guided_partitions, None),

-                            ('Manual - not implemented!',  self.manual_partitions, None),

-                        ]

-        self.menu = Menu(self.menu_starty,  self.maxx, self.items)

-

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', True, self.menu)

-        self.window.addstr(0, 0, 'First, we will setup your disks. \n\nYou can: \n\na) use auto-partitioning or\nb) you can do it manually.')

-

-    def guided_partitions(self, params):

-        return ActionResult(True, {'guided': True, 'devices': self.devices})

-

-    def manual_partitions(self, params):

-        raise NameError('Manual partitioning not implemented')

-

-    def display(self, params):

-        return self.window.do_action()

-

-

-

@@ -1,5 +1,3 @@

-#!/usr/bin/python2

-#

 #    Copyright (C) 2015 vmware inc.

 #

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

@@ -25,10 +23,8 @@ from __builtin__ import isinstance

 class Installer(object):

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

-                 rpm_path = "../stage/RPMS", log_path = "../stage/LOGS",

-                 ks_config = None):

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

         self.install_config = install_config

-        self.ks_config = ks_config

         self.iso_installer = iso_installer

         self.rpm_path = rpm_path

         self.log_path = log_path

@@ -72,7 +68,7 @@ class Installer(object):

     def exit_gracefully(self, signal, frame):

         if self.iso_installer:

             self.progress_bar.hide()

-            self.window.addstr(0, 0, 'Opps, Installer got interrupted.\n\nPress any key to get to the bash...')

+            self.window.addstr(0, 0, 'Oops, Installer got interrupted.\n\nPress any key to get to the bash...')

             self.window.content_window().getch()

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

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

             self.progress_bar.hide()

             self.window.addstr(0, 0, 'Congratulations, Photon has been installed in {0} secs.\n\nPress any key to continue to boot...'.format(self.progress_bar.time_elapsed))

             eject_cdrom = True

-            if self.ks_config == None:

+            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

@@ -428,7 +424,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.ks_config, self.install_config, self.photon_root)

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

     def adjust_packages_for_vmware_virt(self):

         try:

@@ -9,11 +9,13 @@ from ostreeinstaller import OstreeInstaller

 from ostreeserverinstaller import OstreeServerInstaller

 class InstallerContainer(object):

-    def __init__(self, install_config, maxy = 0, maxx = 0, iso_installer = False, rpm_path = "../stage/RPMS", log_path = "../stage/LOGS", ks_config = None):

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

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

+        log_path = "../stage/LOGS"):

+

         self.install_config = install_config

         self.maxy = maxy

         self.maxx = maxx

-        self.ks_config = ks_config

         self.iso_installer = iso_installer

         self.rpm_path = rpm_path

         self.log_path = log_path

@@ -21,10 +23,10 @@ class InstallerContainer(object):

     def install(self, params):

         installer = None

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

-            installer = OstreeInstaller(self.install_config, self.maxy, self.maxx, self.iso_installer, self.rpm_path, self.log_path, self.ks_config)

+            installer = OstreeInstaller(self.install_config, self.maxy, self.maxx, self.iso_installer, self.rpm_path, self.log_path)

         elif self.install_config['type'] == "ostree_server":

-            installer = OstreeServerInstaller(self.install_config, self.maxy, self.maxx, self.iso_installer, self.rpm_path, self.log_path, self.ks_config)

+            installer = OstreeServerInstaller(self.install_config, self.maxy, self.maxx, self.iso_installer, self.rpm_path, self.log_path)

         else:

-            installer = Installer(self.install_config, self.maxy, self.maxx, self.iso_installer, self.rpm_path, self.log_path, self.ks_config)

+            installer = Installer(self.install_config, self.maxy, self.maxx, self.iso_installer, self.rpm_path, self.log_path)

         return installer.install(params)

\ No newline at end of file

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

         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 = ""

@@ -44,14 +45,19 @@ class IsoInstaller(object):

                     err_msg = response.text

                 except Exception as e:

                     err_msg = e

-                modules.commons.log(modules.commons.LOG_ERROR, "Failed to get the kickstart file at {0}, error msg: {1}".format(path, err_msg))

-                print "Failed to get the kickstart file at {0}, retry in a second".format(path)

+

+                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 "Failed to get the kickstart file at {0}, exiting the installer, check the logs for more details".format(path)

+            print(ks_file_error)

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

             raise Exception(err_msg)

         else:

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

@@ -75,9 +81,10 @@ class IsoInstaller(object):

             if retval == 0:

                 self.cd_path = "/mnt/cdrom"

                 return

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

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

             time.sleep(1)

-        print "Failed to mount the cd, exiting the installer, check the logs for more details"

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

@@ -98,14 +105,16 @@ class IsoInstaller(object):

         machinename = fields[0]

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

-    def validate_password(self, text):

+    @staticmethod

+    def validate_password(text):

         try:

             p = cracklib.VeryFascistCheck(text)

         except ValueError, message:

             p = str(message)

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

-    def generate_password_hash(self, 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)]))

         return shadow_password

@@ -136,6 +145,7 @@ class IsoInstaller(object):

         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)

@@ -165,7 +175,7 @@ class IsoInstaller(object):

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

             '*', # echo char

             None, # set of accepted chars

-            self.validate_password, # validation function of the input

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

@@ -175,7 +185,7 @@ class IsoInstaller(object):

             '*', # echo char

             None, # set of accepted chars

             None, # validation function of the input

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

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

@@ -227,6 +237,53 @@ class IsoInstaller(object):

                     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)

@@ -270,22 +327,10 @@ class IsoInstaller(object):

             self.mount_RPMS_cd()

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

-        if not ks_config:

-            self.ui_install(options_file, rpm_path)

+        if ks_config:

+            self.ks_install(options_file, rpm_path, ks_config)

         else:

-            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

-            installer = InstallerContainer(

-                install_config,

-                self.maxy, self.maxx,

-                True,

-                rpm_path=rpm_path,

-                log_path="/var/log",

-                ks_config=ks_config)

-

-            installer.install(None)

+            self.ui_install(options_file, rpm_path)

 if __name__ == '__main__':

     usage = "Usage: %prog [options]"

deleted file mode 100644

@@ -1,30 +0,0 @@

-import os

-import commons

-from jsonwrapper import JsonWrapper

-

-install_phase = commons.PRE_INSTALL

-enabled = True

-

-def get_packages_to_install(options, config_type):

-        package_list = []

-        install_option = options[config_type]

-        for include_type in install_option["include"]:

-            package_list = package_list + get_packages_to_install(options, include_type)

-        json_wrapper_package_list = JsonWrapper(install_option["file"])

-        package_list_json = json_wrapper_package_list.read()

-        package_list = package_list + package_list_json["packages"]

-

-        return package_list

-

-def execute(name, ks_config, config, root):

-

-    if ks_config:

-

-        options = JsonWrapper("build_install_options_all.json").read()

-        packages = get_packages_to_install(options, ks_config['type'])

-

-        if 'additional_packages' in ks_config:

-            packages.extend(ks_config['additional_packages'])

-

-        config['type'] = ks_config['type']

-        config["packages"] = packages

deleted file mode 100644

@@ -1,15 +0,0 @@

-import os

-import subprocess

-import commons

-

-install_phase = commons.PRE_INSTALL

-enabled = True

-

-def execute(name, ks_config, config, root):

-

-    if ks_config:

-        if 'partitions' in ks_config:

-            partitions = ks_config['partitions']

-        else:

-            partitions = commons.default_partitions

-        config['disk'] = commons.partition_disk(ks_config['disk'], partitions)

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

 install_phase = commons.POST_INSTALL

 enabled = True

-def execute(name, ks_config, config, root):

-

-    if ks_config and 'postinstall' in ks_config:

-        config['postinstall'] = ks_config['postinstall']

+def execute(name, config, root):

     if 'postinstall' not in config:

         return

     # run the script in the chroot environment

@@ -20,5 +17,10 @@ def execute(name, ks_config, config, root):

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

     os.chmod(script_file, 0700);

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

-    process.wait()

+    with open("/var/log/installer-kickstart.log","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:

+            return True

+        return False

@@ -5,16 +5,7 @@ import random

 install_phase = commons.POST_INSTALL

 enabled = True

-def execute(name, ks_config, config, root):

-

-    if ks_config:

-        if "hostname" in ks_config:

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

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

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

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

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

-

+def execute(name, config, root):

     hostname = config['hostname']

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

@@ -7,16 +7,7 @@ import string

 install_phase = commons.POST_INSTALL

 enabled = True

-def execute(name, ks_config, config, root):

-

-    if ks_config:

-        # crypt the password if needed

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

-            config['password'] = ks_config['password']['text']

-        else:

-            config['password'] = crypt.crypt(ks_config['password']['text'], 

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

-    

+def execute(name, config, root):

     shadow_password = config['password']

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

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

 install_phase = commons.POST_INSTALL

 enabled = True

-def execute(name, ks_config, config, root):

-    if ks_config and 'public_key' in ks_config:

-        config['public_key'] = ks_config['public_key']

+def execute(name, config, root):

     if 'public_key' not in config:

         return

@@ -12,8 +12,8 @@ from actionresult import ActionResult

 class OstreeInstaller(Installer):

-    def __init__(self, install_config, maxy = 0, maxx = 0, iso_installer = False, rpm_path = "../stage/RPMS", log_path = "../stage/LOGS", ks_config = None):

-        Installer.__init__(self, install_config, maxy, maxx, iso_installer, rpm_path, log_path, ks_config)

+    def __init__(self, install_config, maxy = 0, maxx = 0, iso_installer = False, rpm_path = "../stage/RPMS", log_path = "../stage/LOGS"):

+        Installer.__init__(self, install_config, maxy, maxx, iso_installer, rpm_path, log_path)

         self.repo_config = {}

         self.repo_read_conf()

@@ -93,7 +93,7 @@ class OstreeInstaller(Installer):

         self.window.show_window()

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

         self.progress_bar.show()

-        

+

         self.execute_modules(modules.commons.PRE_INSTALL)

         disk = self.install_config['disk']['disk']

@@ -165,7 +165,7 @@ class OstreeInstaller(Installer):

         self.progress_bar.update_loading_message("Ready to restart")

         self.progress_bar.hide()

         self.window.addstr(0, 0, 'Congratulations, Photon RPM-OSTree Host has been installed in {0} secs.\n\nPress any key to continue to boot...'.format(self.progress_bar.time_elapsed))

-        if self.ks_config == None:

+        if 'ui_install' in self.install_config:

             self.window.content_window().getch()

         return ActionResult(True, None)

@@ -27,8 +27,8 @@ from installer import Installer

 class OstreeServerInstaller(Installer):

-    def __init__(self, install_config, maxy = 0, maxx = 0, iso_installer = False, rpm_path = "../stage/RPMS", log_path = "../stage/LOGS", ks_config = None):

-        Installer.__init__(self, install_config, maxy, maxx, iso_installer, rpm_path, log_path, ks_config)

+    def __init__(self, install_config, maxy = 0, maxx = 0, iso_installer = False, rpm_path = "../stage/RPMS", log_path = "../stage/LOGS"):

+        Installer.__init__(self, install_config, maxy, maxx, iso_installer, rpm_path, log_path)

     def finalize_system(self):

         Installer.finalize_system(self)