@@ -5,7 +5,7 @@ This repository contains signed binaries: bootx64.efi and bootaa64.efi

 # # mv shimx64.efi bootx64.efi

 # grubx64.efi is generated on Photon OS by using grub2-efi-2.02-12:

-# # grub2-mkimage -o grubx64.efi -p /boot/grub2 -O x86_64-efi  fat iso9660 part_gpt part_msdos  normal boot linux configfile loopback chain  efifwsetup efi_gop efi_uga  ls search search_label search_fs_uuid search_fs_file  gfxterm gfxterm_background gfxterm_menu test all_video loadenv  exfat ext2 udf halt gfxmenu png tga lsefi help probe echo

+# # grub2-mkimage -o grubx64.efi -p /boot/grub2 -O x86_64-efi fat iso9660 part_gpt part_msdos normal boot linux configfile loopback chain efifwsetup efi_gop efi_uga ls search search_label search_fs_uuid search_fs_file gfxterm gfxterm_background gfxterm_menu test all_video loadenv exfat ext2 udf halt gfxmenu png tga lsefi help probe echo lvm

 # grubaa64.efi is generated on Photon OS (aarch64) by using grub2-efi >= 2.02-11:

 # cat > /tmp/grub-embed-config.cfg << EOF

@@ -11,7 +11,8 @@ class CommandUtils(object):

     def run(self, cmd):

         self.logger.debug(cmd)

-        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

+        use_shell = not isinstance(cmd, list)

+        process = subprocess.Popen(cmd, shell=use_shell, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

         out,err = process.communicate()

         retval = process.returncode

         if out != b'':

@@ -22,6 +23,17 @@ class CommandUtils(object):

             self.logger.error(err.decode())

         return retval

+    def run_in_chroot(self, chroot_path, cmd):

+        # Use short command here. Initial version was:

+        # chroot "${BUILDROOT}" \

+        #   /usr/bin/env -i \

+        #   HOME=/root \

+        #   TERM="$TERM" \

+        #   PS1='\u:\w\$ ' \

+        #   PATH=/bin:/usr/bin:/sbin:/usr/sbin \

+        #   /usr/bin/bash --login +h -c "cd installer;$*"

+        return self.run(['chroot', chroot_path, '/bin/bash', '-c', cmd])

+

     @staticmethod

     def is_vmware_virtualization():

         """Detect vmware vm"""

@@ -13,6 +13,7 @@ import glob

 import modules.commons

 import random

 import curses

+import stat

 from logger import Logger

 from commandutils import CommandUtils

 from jsonwrapper import JsonWrapper

@@ -38,12 +39,14 @@ class Installer(object):

     known_keys = {

         'additional_packages',

         'additional_rpms_path',

+        'arch',

         'autopartition',

         'bootmode',

         'disk',

         'eject_cdrom',

         'hostname',

         'install_linux_esx',

+        'live',

         'log_level',

         'ostree',

         'packages',

@@ -59,11 +62,6 @@ class Installer(object):

         'ui'

     }

-    mount_command = os.path.dirname(__file__)+"/mk-mount-disk.sh"

-    prepare_command = os.path.dirname(__file__)+"/mk-prepare-system.sh"

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

-    chroot_command = os.path.dirname(__file__)+"/mk-run-chroot.sh"

-    unmount_disk_command = os.path.dirname(__file__)+"/mk-unmount-disk.sh"

     default_partitions = [{"mountpoint": "/", "size": 0, "filesystem": "ext4"}]

     def __init__(self, working_directory="/mnt/photon-root",

@@ -158,14 +156,23 @@ class Installer(object):

         else:

             install_config['packages'] = packages

+        # set arch to host's one if not defined

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

+        if 'arch' not in install_config:

+            install_config['arch'] = arch

+

         # 'bootmode' mode

         if 'bootmode' not in install_config:

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

             if "x86_64" in arch:

                 install_config['bootmode'] = 'dualboot'

             else:

                 install_config['bootmode'] = 'efi'

+        # live means online system. When you create an image for

+        # target system, live should be set to false.

+        if 'live' not in install_config:

+            install_config['live'] = 'loop' not in install_config['disk']

+

         # default partition

         if 'partitions' not in install_config:

             install_config['partitions'] = Installer.default_partitions

@@ -232,6 +239,13 @@ class Installer(object):

         if not has_root:

             return "There is no partition assigned to root '/'"

+        if install_config['arch'] not in ["aarch64", 'x86_64']:

+            return "Unsupported target architecture {}".format(install_config['arch'])

+

+        # No BIOS for aarch64

+        if install_config['arch'] == 'aarch64' and install_config['bootmode'] in ['dualboot', 'bios']:

+            return "Aarch64 targets do not support BIOS boot. Set 'bootmode' to 'efi'."

+

         return None

     def _install(self, stdscreen=None):

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

         else:

             self._setup_install_repo()

             self._initialize_system()

+            self._mount_special_folders()

             self._install_packages()

             self._install_additional_rpms()

             self._enable_network_in_chroot()

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

             self._create_fstab()

         self._execute_modules(modules.commons.POST_INSTALL)

         self._disable_network_in_chroot()

-        self._unmount_partitions()

+        self._unmount_all()

     def exit_gracefully(self, signal1=None, frame1=None):

         """

@@ -313,7 +328,7 @@ class Installer(object):

         """

         del signal1

         del frame1

-        if not self.exiting:

+        if not self.exiting and self.install_config:

             self.exiting = True

             if self.install_config['ui']:

                 self.progress_bar.hide()

@@ -322,18 +337,26 @@ class Installer(object):

                 self.window.content_window().getch()

             self._cleanup_install_repo()

-            self._unmount_partitions()

+            self._unmount_all()

         sys.exit(1)

-    def _unmount_partitions(self):

+    def _unmount_all(self):

         """

-        Unmount partitions

+        Unmount partitions and special folders

         """

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

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

-        retval = self.cmd.run(command)

-        if retval != 0:

-            self.logger.error("Failed to unmount disks")

+        for d in ["/run", "/sys", "/dev/pts", "/dev", "/proc"]:

+            retval = self.cmd.run(['umount', '-l', self.photon_root + d])

+            if retval != 0:

+                self.logger.error("Failed to unmount {}".format(d))

+

+        for partition in self.install_config['partitions'][::-1]:

+            if self._get_partition_type(partition) in [PartitionType.BIOS, PartitionType.SWAP]:

+                continue

+            mountpoint = self.photon_root + partition["mountpoint"]

+            retval = self.cmd.run(['umount', '-l', mountpoint])

+            if retval != 0:

+                self.logger.error("Failed to unmount partition {}".format(mountpoint))

+

         # need to call it twice, because of internal bind mounts

         if 'ostree' in self.install_config:

             retval = self.cmd.run(['umount', '-R', self.photon_root])

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

             if retval != 0:

                 self.logger.error("Failed to unmount disks in photon root")

+        self.cmd.run(['sync'])

         shutil.rmtree(self.photon_root)

         # Deactivate LVM VGs

@@ -411,6 +435,21 @@ class Installer(object):

                 self.cmd.run(['rm', '-rf', self.rpm_cache_dir]) != 0):

             self.logger.error("Fail to unbind cache rpms")

+    def _get_partuuid(self, path):

+        partuuid = subprocess.check_output(['blkid', '-s', 'PARTUUID', '-o', 'value', path],

+                                       universal_newlines=True).rstrip('\n')

+        # Backup way to get uuid/partuuid. Leave it here for later use.

+        #if partuuidval == '':

+        #    sgdiskout = Utils.runshellcommand(

+        #        "sgdisk -i 2 {} ".format(disk_device))

+        #    partuuidval = (re.findall(r'Partition unique GUID.*',

+        #                          sgdiskout))[0].split(':')[1].strip(' ').lower()

+        return partuuid

+

+    def _get_uuid(self, path):

+        return subprocess.check_output(['blkid', '-s', 'UUID', '-o', 'value', path],

+                                       universal_newlines=True).rstrip('\n')

+

     def _create_fstab(self, fstab_path = None):

         """

         update fstab

@@ -440,8 +479,23 @@ class Installer(object):

                 else:

                     mountpoint = partition['mountpoint']

+                # Use PARTUUID/UUID instead of bare path.

+                # Prefer PARTUUID over UUID as it is supported by kernel

+                # and UUID only by initrd.

+                path = partition['path']

+                mnt_src = None

+                partuuid = self._get_partuuid(path)

+                if partuuid != '':

+                    mnt_src = "PARTUUID={}".format(partuuid)

+                else:

+                    uuid = self._get_uuid(path)

+                    if uuid != '':

+                        mnt_src = "UUID={}".format(uuid)

+                if not mnt_src:

+                    raise RuntimeError("Cannot get PARTUUID/UUID of: {}".format(path))

+

                 fstab_file.write("{}\t{}\t{}\t{}\t{}\t{}\n".format(

-                    partition['path'],

+                    mnt_src,

                     mountpoint,

                     partition['filesystem'],

                     options,

@@ -468,13 +522,15 @@ class Installer(object):

         return params

     def _mount_partitions(self):

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

-        command.extend(self._generate_partitions_param())

-        retval = self.cmd.run(command)

-        if retval != 0:

-            self.logger.info("Failed to mount partitions for installation")

-            self.exit_gracefully()

-

+        for partition in self.install_config['partitions'][::1]:

+            if self._get_partition_type(partition) in [PartitionType.BIOS, PartitionType.SWAP]:

+                continue

+            mountpoint = self.photon_root + partition["mountpoint"]

+            self.cmd.run(['mkdir', '-p', mountpoint])

+            retval = self.cmd.run(['mount', '-v', partition["path"], mountpoint])

+            if retval != 0:

+                self.logger.error("Failed to mount partition {}".format(partition["path"]))

+                self.exit_gracefully()

     def _initialize_system(self):

         """

@@ -484,10 +540,48 @@ class Installer(object):

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

         self._bind_installer()

         self._bind_repo_dir()

-        retval = self.cmd.run([Installer.prepare_command, '-w', self.photon_root,

-                               self.working_directory, self.rpm_cache_dir])

+

+        # Initialize rpm DB

+        self.cmd.run(['mkdir', '-p', os.path.join(self.photon_root, "var/lib/rpm")])

+        retval = self.cmd.run(['rpm', '--root', self.photon_root, '--initdb',

+                               '--dbpath', '/var/lib/rpm'])

+        if retval != 0:

+            self.logger.error("Failed to initialize rpm DB")

+            self.exit_gracefully()

+

+        # Install filesystem rpm

+        tdnf_cmd = "tdnf install filesystem --installroot {0} --assumeyes -c {1}".format(self.photon_root,

+                        self.tdnf_conf_path)

+        retval = self.cmd.run(tdnf_cmd)

+        if retval != 0:

+            retval = self.cmd.run(['docker', 'run',

+                                   '-v', self.rpm_cache_dir+':'+self.rpm_cache_dir,

+                                   '-v', self.working_directory+':'+self.working_directory,

+                                   'photon:3.0', '/bin/sh', '-c', tdnf_cmd])

+            if retval != 0:

+                self.logger.error("Failed to install filesystem rpm")

+                self.exit_gracefully()

+

+        # Create special devices (TODO: really need it?)

+        devices = {

+            'console': (600, stat.S_IFCHR, 5, 1),

+            'null': (666, stat.S_IFCHR, 1, 3),

+            'random': (444, stat.S_IFCHR, 1, 8),

+            'urandom': (444, stat.S_IFCHR, 1, 9)

+        }

+        for device, (mode, dev_type, major, minor) in devices.items():

+            os.mknod(os.path.join(self.photon_root, "dev", device),

+                    mode | dev_type, os.makedev(major, minor))

+

+    def _mount_special_folders(self):

+        for d in ["/proc", "/dev", "/dev/pts", "/sys"]:

+            retval = self.cmd.run(['mount', '-o', 'bind', d, self.photon_root + d])

+            if retval != 0:

+                self.logger.error("Failed to bind mount {}".format(d))

+                self.exit_gracefully()

+        retval = self.cmd.run(['mount', '-t', 'tmpfs', 'tmpfs', self.photon_root + "/run"])

         if retval != 0:

-            self.logger.info("Failed to bind the installer and repo needed by tdnf")

+            self.logger.error("Failed to bind mount {}".format(d))

             self.exit_gracefully()

     def _finalize_system(self):

@@ -497,10 +591,17 @@ class Installer(object):

         if self.install_config['ui']:

             self.progress_bar.show_loading('Finalizing installation')

-        retval = self.cmd.run([Installer.chroot_command, '-w', self.photon_root,

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

-        if retval != 0:

-            self.logger.error("Fail to setup the target system after the installation")

+        self.cmd.run_in_chroot(self.photon_root, "/sbin/ldconfig")

+        self.cmd.run_in_chroot(self.photon_root, "/bin/systemd-machine-id-setup")

+        # Importing the pubkey

+        self.cmd.run_in_chroot(self.photon_root, "rpm --import /etc/pki/rpm-gpg/*")

+        # Set locale

+        with open(os.path.join(self.photon_root, "etc/locale.conf"), "w") as locale_conf:

+            locale_conf.write("LANG=en_US.UTF-8\n")

+        #locale-gen.sh needs /usr/share/locale/locale.alias which is shipped with

+        #  glibc-lang rpm, in some photon installations glibc-lang rpm is not installed

+        #  by default. Call localedef directly here to define locale environment.

+        self.cmd.run_in_chroot(self.photon_root, "/usr/bin/localedef -c -i en_US -f UTF-8 en_US.UTF-8")

     def _cleanup_install_repo(self):

         self._unbind_installer()

@@ -513,10 +614,59 @@ class Installer(object):

         os.remove(self.tdnf_repo_path)

     def _setup_grub(self):

+        bootmode = self.install_config['bootmode']

+

+        self.cmd.run(['mkdir', '-p', self.photon_root + '/boot/grub2'])

+        self.cmd.run(['ln', '-sfv', 'grub2', self.photon_root + '/boot/grub'])

+

+        # Setup bios grub

+        if bootmode == 'dualboot' or bootmode == 'bios':

+            retval = self.cmd.run(['grub2-install', '--target=i386-pc', '--force',

+                                   '--boot-directory={}'.format(self.photon_root + "/boot"),

+                                   self.install_config['disk']])

+            if retval != 0:

+                retval = self.cmd.run(['grub-install', '--target=i386-pc', '--force',

+                                   '--boot-directory={}'.format(self.photon_root + "/boot"),

+                                   self.install_config['disk']])

+                if retval != 0:

+                    raise Exception("Unable to setup grub")

+

+        # Setup efi grub

+        if bootmode == 'dualboot' or bootmode == 'efi':

+            esp_pn = '1'

+            if bootmode == 'dualboot':

+                esp_pn = '2'

+

+            self.cmd.run(['mkdir', '-p', self.photon_root + '/boot/efi/EFI/BOOT'])

+            if self.install_config['arch'] == 'aarch64':

+                shutil.copy(self.installer_path + '/EFI_aarch64/BOOT/bootaa64.efi', self.photon_root + '/boot/efi/EFI/BOOT')

+                exe_name='bootaa64.efi'

+            if self.install_config['arch'] == 'x86_64':

+                shutil.copy(self.installer_path + '/EFI_x86_64/BOOT/bootx64.efi', self.photon_root + '/boot/efi/EFI/BOOT')

+                shutil.copy(self.installer_path + '/EFI_x86_64/BOOT/grubx64.efi', self.photon_root + '/boot/efi/EFI/BOOT')

+                exe_name='bootx64.efi'

+

+            self.cmd.run(['mkdir', '-p', self.photon_root + '/boot/efi/boot/grub2'])

+            with open(os.path.join(self.photon_root, 'boot/efi/boot/grub2/grub.cfg'), "w") as grub_cfg:

+                grub_cfg.write("search -n -u {} -s\n".format(self._get_uuid(self.install_config['partitions_data']['boot'])))

+                grub_cfg.write("configfile {}grub2/grub.cfg\n".format(self.install_config['partitions_data']['bootdirectory']))

+

+            if self.install_config['live']:

+                # Some platforms do not support adding boot entry. Thus, ignore failures

+                self.cmd.run(['efibootmgr', '--create', '--remove-dups', '--disk', self.install_config['disk'],

+                              '--part', esp_pn, '--loader', '/EFI/BOOT/' + exe_name, '--label', 'Photon'])

+

+        # Copy grub theme files

+        shutil.copy(self.installer_path + '/boot/ascii.pf2', self.photon_root + '/boot/grub2')

+        self.cmd.run(['mkdir', '-p', self.photon_root + '/boot/grub2/themes/photon'])

+        shutil.copy(self.installer_path + '/boot/splash.png', self.photon_root + '/boot/grub2/themes/photon/photon.png')

+        shutil.copy(self.installer_path + '/boot/theme.txt', self.photon_root + '/boot/grub2/themes/photon')

+        for f in glob.glob(os.path.abspath(self.installer_path) + '/boot/terminal_*.tga'):

+            shutil.copy(f, self.photon_root + '/boot/grub2/themes/photon')

+

+        # Create custom grub.cfg

         retval = self.cmd.run(

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

-             self.install_config.get('bootmode', 'bios'),

-             self.install_config['disk'],

+            [self.setup_grub_command, self.photon_root,

              self.install_config['partitions_data']['root'],

              self.install_config['partitions_data']['boot'],

              self.install_config['partitions_data']['bootdirectory']])

@@ -726,7 +876,7 @@ class Installer(object):

             return PartitionType.BIOS

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

             return PartitionType.SWAP

-        if partition.get('mountpoint', '') == '/boot/esp' and partition['filesystem'] == 'vfat':

+        if partition.get('mountpoint', '') == '/boot/efi' and partition['filesystem'] == 'vfat':

             return PartitionType.ESP

         if partition.get('lvm', None):

             return PartitionType.LVM

@@ -875,7 +1025,7 @@ class Installer(object):

         # Insert efi special partition

         if not esp_found and (bootmode == 'dualboot' or bootmode == 'efi'):

-            efi_partition = { 'size': 8, 'filesystem': 'vfat', 'mountpoint': '/boot/esp' }

+            efi_partition = { 'size': 8, 'filesystem': 'vfat', 'mountpoint': '/boot/efi' }

             self.install_config['partitions'].insert(0, efi_partition)

         # Insert bios partition last to be very first

@@ -145,13 +145,21 @@ class IsoConfig(object):

         items = self.add_ui_pages(install_config, ui_config, maxy, maxx)

         index = 0

+        # Used to continue direction if some screen was skipped

+        go_next=True

+

+        # UI screens showing

         while True:

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

-            if result.success:

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

+            # Skip inactive window and continue previos direction.

+            if ar.result and ar.result.get('inactive_screen', False):

+                ar.success = go_next

+            go_next = ar.success

+            if ar.success:

                 index += 1

                 if index == len(items):

                     # confirm window

-                    if result.result['yes']:

+                    if ar.result['yes']:

                         break

                     else:

                         exit(0)

@@ -6,6 +6,14 @@ Kickstart config file is a json format with following possible parameters:

 	Provide a path containing additional RPMS that are to be bundled into

 	the image.

+"arch" (optional)

+	Target system architecture. Should be set if target architecture is

+	different from host one, for instance x86_64 machine building RPi

+	image.

+	Acceptible values are: "x86_64", "aarch64"

+	Defatult value: autodetected host architecture

+	Example: { "arch": "aarch64" }

+

 "bootmode" (optional)

 	Sets the boot type to suppot: EFI, BIOS or both.

 	Acceptible values are: "bios", "efi", "dualboot"

@@ -105,7 +113,7 @@ Kickstart config file is a json format with following possible parameters:

 				 }

 			},

 			{

-				"mountpoint": "/boot/esp",

+				"mountpoint": "/boot/efi",

 				"size": 12,

 				"filesystem": "vfat",

 				"fs_options": "-n EFI"

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

     def display(self):

         if 'ostree' in self.install_config:

-            return ActionResult(True, None)

+            return ActionResult(None, {"inactive_screen": True})

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

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

deleted file mode 100755

@@ -1,38 +0,0 @@

-#!/bin/bash

-#################################################

-#       Title:  mk-finalize-system              #

-#        Date:  2014-11-26                      #

-#     Version:  1.0                             #

-#      Author:  mbassiouny@vmware.com           #

-#     Options:                                  #

-#################################################

-#   Overview

-#       Finalize the system after the installation

-#   End

-#

-set -o errexit      # exit if error...insurance ;

-set -o nounset      # exit if variable not initalized

-set +h          # disable hashall

-set -x

-SCRIPT_PATH=$(dirname $(realpath -s $0))

-source $SCRIPT_PATH/config.inc

-PRGNAME=${0##*/}    # script name minus the path

-[ ${EUID} -eq 0 ]   || fail "${PRGNAME}: Need to be root user: FAILURE"

-

-/sbin/ldconfig

-/usr/sbin/pwconv

-/usr/sbin/grpconv

-/bin/systemd-machine-id-setup

-/usr/bin/touch /etc/locale.conf

-/bin/echo "LANG=en_US.UTF-8" > /etc/locale.conf

-

-# Importing the pubkey

-rpm --import /etc/pki/rpm-gpg/*

-

-#locale-gen.sh needs /usr/share/locale/locale.alias which is shipped with

-#  glibc-lang rpm, in some photon installations glibc-lang rpm is not installed

-#  by default. Call localedef directly here to define locale environment.

-/usr/bin/localedef -c -i en_US -f UTF-8 en_US.UTF-8

-#/sbin/locale-gen.sh

-

-exit 0

deleted file mode 100755

@@ -1,46 +0,0 @@

-#!/bin/bash

-#################################################

-#       Title:  mk-mount-disk                   #

-#        Date:  2014-11-26                      #

-#     Version:  1.0                             #

-#      Author:  mbassiouny@vmware.com           #

-#     Options:                                  #

-#################################################

-#	Overview

-#		This mount a partition passed in arguments or a in the config.inc in root photon mount directory

-#	End

-#

-set -o errexit		# exit if error...insurance ;

-set -o nounset		# exit if variable not initalized

-set +h			# disable hashall

-set -x

-PRGNAME=${0##*/}	# script name minus the path

-SCRIPT_PATH=$(dirname $(realpath -s $0))

-source $SCRIPT_PATH/config.inc		#	configuration parameters

-source $SCRIPT_PATH/function.inc

-LOGFILE=/var/log/"${PRGNAME}-${LOGFILE}"	#	set log file name

-#LOGFILE=/dev/null		#	uncomment to disable log file

-[ ${EUID} -eq 0 ]	|| fail "${PRGNAME}: Need to be root user: FAILURE"

-> ${LOGFILE}		#	clear/initialize logfile

-

-while [[ $# > 0 ]]

-do

-    key="$1"

-    shift

- 

-    case $key in

-        -p|--partitionmountpoint)

-        PARTITION="$1"

-        MOUNTPOINT="$2"

-        shift 2

-

-        # make sure the directory exists

-        run_command "Making Directory" "mkdir -p ${BUILDROOT}${MOUNTPOINT}" "${LOGFILE}"

-        run_command "Mounting Partition" "mount -v ${PARTITION} ${BUILDROOT}${MOUNTPOINT}" "${LOGFILE}"

-    ;;

-    *)

-        # unknown option

-    ;;

-    esac

-done

-

deleted file mode 100755

@@ -1,59 +0,0 @@

-#!/bin/bash

-#################################################

-#       Title:  mk-prepare-system               #

-#        Date:  2014-11-26                      #

-#     Version:  1.0                             #

-#      Author:  mbassiouny@vmware.com           #

-#     Options:                                  #

-#################################################

-#   Overview

-#       Preparing the system to install photon

-#   End

-#

-set -o errexit      # exit if error...insurance ;

-set -o nounset      # exit if variable not initalized

-set +h          # disable hashall

-set -x

-SCRIPT_PATH=$(dirname $(realpath -s $0))

-source $SCRIPT_PATH/config.inc

-source $SCRIPT_PATH/function.inc

-PRGNAME=${0##*/}    # script name minus the path

-

-LOGFILE=/var/log/"${PRGNAME}-${LOGFILE}"    #   set log file name

-#LOGFILE=/dev/null      #   uncomment to disable log file

-

-[ ${EUID} -eq 0 ]   || fail "${PRGNAME}: Need to be root user: FAILURE"

-[ -z ${BUILDROOT} ] && fail "${PRGNAME}: Build root not set: FAILURE"

-

-WORKINGDIR=$1

-RPMS_PATH=$2

-

-if mountpoint ${BUILDROOT}/run  >/dev/null 2>&1; then umount ${BUILDROOT}/run; fi

-if mountpoint ${BUILDROOT}/sys  >/dev/null 2>&1; then umount ${BUILDROOT}/sys; fi

-if mountpoint ${BUILDROOT}/proc >/dev/null 2>&1; then umount ${BUILDROOT}/proc; fi

-if mountpoint ${BUILDROOT}/dev/pts  >/dev/null 2>&1; then umount ${BUILDROOT}/dev/pts; fi

-if mountpoint ${BUILDROOT}/dev  >/dev/null 2>&1; then umount ${BUILDROOT}/dev; fi

-

-mkdir -p ${BUILDROOT}/var/lib/rpm

-mkdir -p ${BUILDROOT}/cache/tdnf

-rpm --root ${BUILDROOT} --initdb --dbpath /var/lib/rpm

-# tdnf conf is created in working directory which is parent of buildroot

-tdnf install filesystem --installroot ${BUILDROOT} --assumeyes -c ${WORKINGDIR}/tdnf.conf || \

-    docker run -v $RPMS_PATH:$RPMS_PATH -v $WORKINGDIR:$WORKINGDIR photon:3.0 \

-	tdnf install filesystem --installroot ${BUILDROOT} --assumeyes -c ${WORKINGDIR}/tdnf.conf

- 

-#   Ommited in the filesystem.spec file - not needed for booting

-[ -e ${BUILDROOT}/dev/console ] || mknod -m 600 ${BUILDROOT}/dev/console c 5 1

-[ -e ${BUILDROOT}/dev/null ]    || mknod -m 666 ${BUILDROOT}/dev/null c 1 3

-[ -e ${BUILDROOT}/dev/random ]  || mknod -m 444 ${BUILDROOT}/dev/random c 1 8

-[ -e ${BUILDROOT}/dev/urandom ] || mknod -m 444 ${BUILDROOT}/dev/urandom c 1 9

-

-#   Mount kernel filesystem

-#

-if ! mountpoint ${BUILDROOT}/dev    >/dev/null 2>&1; then mount --bind /dev ${BUILDROOT}/dev; fi

-if ! mountpoint ${BUILDROOT}/dev/pts    >/dev/null 2>&1; then mount -t devpts devpts ${BUILDROOT}/dev/pts -o gid=5,mode=620; fi

-if ! mountpoint ${BUILDROOT}/proc   >/dev/null 2>&1; then mount -t proc proc ${BUILDROOT}/proc; fi

-if ! mountpoint ${BUILDROOT}/sys    >/dev/null 2>&1; then mount -t sysfs sysfs ${BUILDROOT}/sys; fi

-if ! mountpoint ${BUILDROOT}/run    >/dev/null 2>&1; then mount -t tmpfs tmpfs ${BUILDROOT}/run; fi

-if [ -h ${BUILDROOT}/dev/shm ];          then mkdir -pv ${BUILDROOT}/$(readlink ${BUILDROOT}/dev/shm); fi

-exit 0

deleted file mode 100755

@@ -1,37 +0,0 @@

-#!/bin/bash

-#################################################

-#       Title:  mk-run-chroot                   #

-#        Date:  2014-11-26                      #

-#     Version:  1.0                             #

-#      Author:  mbassiouny@vmware.com           #

-#     Options:                                  #

-#################################################

-#   Overview

-#       Run the passed command into the chroot

-#   End

-#

-set -o errexit      # exit if error...insurance ;

-set -o nounset      # exit if variable not initalized

-set +h          # disable hashall

-set -x

-SCRIPT_PATH=$(dirname $(realpath -s $0))

-source $SCRIPT_PATH/config.inc

-PRGNAME=${0##*/}    # script name minus the path

-[ ${EUID} -eq 0 ]   || fail "${PRGNAME}: Need to be root user: FAILURE"

-[ -z ${BUILDROOT} ] && fail "${PRGNAME}: Build root not set: FAILURE"

-

-# Remove the name of this script from our argument list

-#shift

-

-#

-#   Goto chroot and run the command specified as parameter.

-#

-chroot "${BUILDROOT}" \

-    /usr/bin/env -i \

-    HOME=/root \

-    TERM="$TERM" \

-    PS1='\u:\w\$ ' \

-    PATH=/bin:/usr/bin:/sbin:/usr/sbin \

-    /usr/bin/bash --login +h -c "cd installer;$*"

-

-exit 0

@@ -1,81 +1,15 @@

-#!/bin/bash

-#################################################

-#       Title:  mk-setup-grub                   #

-#        Date:  2014-11-26                      #

-#     Version:  1.0                             #

-#      Author:  sharathg@vmware.com             #

-#     Options:                                  #

-#################################################

-#    Overview

-#        This is a precursor for the vmware build system.

-#        This assumes that an empty hard disk is attached to the build VM.

-#        The path to this empty disk is specified in the HDD variable in config.inc

-#    End

-#

-

-grub_efi_install()

-{

-    mkdir -p $BUILDROOT/boot/efi

-    #

-    # if it is a loop device then we should mount the dev mapped boot partition

-    #

-    if [[ $HDD == *"loop"* ]]

-    then

-         BOOT_PARTITION=/dev/mapper/`basename ${HDD}`p$EFI_PARTITION_NUMBER

-    elif [[ $HDD == *"nvme"* || $HDD == *"mmcblk"* ]]

-    then

-         BOOT_PARTITION=${HDD}p$EFI_PARTITION_NUMBER

-    else

-         BOOT_PARTITION=${HDD}$EFI_PARTITION_NUMBER

-    fi

-    mount -t vfat $BOOT_PARTITION $BUILDROOT/boot/efi

-    cp $INSTALLER_PATH/boot/unifont.pf2 /usr/share/grub/

-    mkdir -p $BUILDROOT/boot/efi/EFI/Boot/

-    if [ $(uname -m) == "aarch64" ]

-    then

-        cp $INSTALLER_PATH/EFI_aarch64/BOOT/* $BUILDROOT/boot/efi/EFI/Boot/

-        local EXE_NAME="bootaa64.efi"

-    elif [ $(uname -m) == "x86_64" ]

-    then

-        cp $INSTALLER_PATH/EFI_x86_64/BOOT/* $BUILDROOT/boot/efi/EFI/Boot/

-        local EXE_NAME="bootx64.efi"

-    fi

-

-    mkdir -p $BUILDROOT/boot/efi/boot/grub2

-    cat > $BUILDROOT/boot/efi/boot/grub2/grub.cfg << EOF

-search -n -u ${BOOT_UUID} -s

-configfile ${BOOT_DIRECTORY}grub2/grub.cfg

-EOF

-    # Some platforms do not support adding boot entry. Thus, ignore failures.

-    efibootmgr --create --remove-dups --disk "$HDD" --part $EFI_PARTITION_NUMBER --loader "/EFI/Boot/$EXE_NAME" --label Photon --verbose >&2 || :

-    umount $BUILDROOT/boot/efi

-}

-

-grub_mbr_install()

-{

-    $grubInstallCmd --target=i386-pc --force --boot-directory=$BUILDROOT/boot "$HDD"

-}

+#! /bin/bash

 set -o errexit        # exit if error...insurance ;)

 set -o nounset        # exit if variable not initalized

 set +h            # disable hashall

 set -x

-PRGNAME=${0##*/}    # script name minus the path

 SCRIPT_PATH=$(dirname $(realpath -s $0))

-INSTALLER_PATH=$SCRIPT_PATH

-source $SCRIPT_PATH/config.inc        #    configuration parameters

-source $SCRIPT_PATH/function.inc        #    commonn functions

-LOGFILE=/var/log/"${PRGNAME}-${LOGFILE}"    #    set log file name

-ARCH=$(uname -m)    # host architecture

-[ ${EUID} -eq 0 ]    || fail "${PRGNAME}: Need to be root user: FAILURE"

-> ${LOGFILE}        #    clear/initialize logfile

-BOOTMODE=$1

-HDD=$2

-ROOT_PARTITION_PATH=$3

-BOOT_PARTITION_PATH=$4

-BOOT_DIRECTORY=$5

-EFI_PARTITION_NUMBER="1"

+BUILDROOT=$1

+ROOT_PARTITION_PATH=$2

+BOOT_PARTITION_PATH=$3

+BOOT_DIRECTORY=$4

 #

 #    Install grub2.

@@ -83,41 +17,10 @@ EFI_PARTITION_NUMBER="1"

 PARTUUID=$(blkid -s PARTUUID -o value $ROOT_PARTITION_PATH)

 BOOT_UUID=$(blkid -s UUID -o value $BOOT_PARTITION_PATH)

-grubInstallCmd=""

-mkdir -p $BUILDROOT/boot/grub2

-ln -sfv grub2 $BUILDROOT/boot/grub

-command -v grub-install >/dev/null 2>&1 && grubInstallCmd="grub-install" && { echo >&2 "Found grub-install"; }

-command -v grub2-install >/dev/null 2>&1 && grubInstallCmd="grub2-install" && { echo >&2 "Found grub2-install"; }

-

-if [ "$BOOTMODE" == "bios" ]; then

-    if [ -z $grubInstallCmd ]; then

-        echo "Unable to find grub install command"

-        exit 1

-    fi

-    grub_mbr_install

-elif [ "$BOOTMODE" == "efi" ]; then

-    grub_efi_install

-elif [ "$BOOTMODE" == "dualboot" ]; then

-    EFI_PARTITION_NUMBER="2"

-    if [ -z $grubInstallCmd ]; then

-        echo "Unable to find grub install command"

-        exit 1

-    fi

-    grub_mbr_install

-

-    grub_efi_install

-fi

-

-rm -rf ${BUILDROOT}/boot/grub2/fonts

-cp $INSTALLER_PATH/boot/ascii.pf2 ${BUILDROOT}/boot/grub2/

-mkdir -p ${BUILDROOT}/boot/grub2/themes/photon

-cp $INSTALLER_PATH/boot/splash.png ${BUILDROOT}/boot/grub2/themes/photon/photon.png

-cp $INSTALLER_PATH/boot/terminal_*.tga ${BUILDROOT}/boot/grub2/themes/photon/

-cp $INSTALLER_PATH/boot/theme.txt ${BUILDROOT}/boot/grub2/themes/photon/

 # linux-esx tries to mount rootfs even before nvme got initialized.

 # rootwait fixes this issue

 EXTRA_PARAMS=""

-if [[ $HDD == *"nvme"* ]]; then

+if [[ $ROOT_PARTITION_PATH == *"nvme"* ]]; then

     EXTRA_PARAMS=rootwait

 fi

deleted file mode 100755

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

-#!/bin/bash

-#################################################

-#       Title:  mk-unmount-disk                 #

-#        Date:  2014-11-26                      #

-#     Version:  1.0                             #

-#      Author:  mbassiouny@vmware.com           #

-#     Options:                                  #

-#################################################

-#   Overview

-#       This unmount the mounted directories after installing photon

-#   End

-#

-set -o errexit      # exit if error...insurance ;

-set -o nounset      # exit if variable not initalized

-set +h          # disable hashall

-set -x

-SCRIPT_PATH=$(dirname $(realpath -s $0))

-source $SCRIPT_PATH/config.inc

-PRGNAME=${0##*/}    # script name minus the path

-LOGFILE=/var/log/"${PRGNAME}-${LOGFILE}"    #   set log file name

-#LOGFILE=/dev/null      #   uncomment to disable log file

-[ ${EUID} -eq 0 ]   || fail "${PRGNAME}: Need to be root user: FAILURE"

-[ -z ${BUILDROOT} ]     && fail "${PRGNAME}: BUILDROOT not set: FAILURE"

-

-if mountpoint ${BUILDROOT}/run >/dev/null 2>&1; then umount -l ${BUILDROOT}/run; fi

-if mountpoint ${BUILDROOT}/sys >/dev/null 2>&1; then umount -l ${BUILDROOT}/sys; fi

-if mountpoint ${BUILDROOT}/proc    >/dev/null 2>&1; then umount -l ${BUILDROOT}/proc; fi

-if mountpoint ${BUILDROOT}/dev/pts >/dev/null 2>&1; then umount ${BUILDROOT}/dev/pts; fi

-if mountpoint ${BUILDROOT}/dev >/dev/null 2>&1; then umount ${BUILDROOT}/dev; fi

-sync

-while [[ $# > 0 ]]

-do

-    key="$1"

-    shift

- 

-    case $key in

-        -p|--partitionmountpoint)

-        PARTITION="$1"

-        MOUNTPOINT="$2"

-        shift 2

-

-        # make sure the directory exists

-        if mountpoint ${BUILDROOT}${MOUNTPOINT} >/dev/null 2>&1; then umount -l ${BUILDROOT}${MOUNTPOINT}; fi

-        sync

-    ;;

-    *)

-        # unknown option

-    ;;

-    esac

-done

-exit 0

@@ -19,5 +19,5 @@ def execute(installer):

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

     os.chmod(script_file, 0o700)

-    return installer.cmd.run(["./mk-run-chroot.sh", '-w', installer.photon_root,

-                              "/etc/tmpfiles.d/postinstall.sh"]) == 0

+    return installer.cmd.run_in_chroot(installer.photon_root,

+                                       "/etc/tmpfiles.d/postinstall.sh") == 0

@@ -24,3 +24,6 @@ def execute(installer):

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

+

+    installer.cmd.run_in_chroot(installer.photon_root, "/usr/sbin/pwconv")

+    installer.cmd.run_in_chroot(installer.photon_root, "/usr/sbin/grpconv")

@@ -1,98 +1,27 @@

 #!/bin/bash

-#################################################

-#       Title:  mk-setup-grub                   #

-#        Date:  2014-11-26                      #

-#     Version:  1.0                             #

-#      Author:  sharathg@vmware.com             #

-#     Options:                                  #

-#################################################

-#   Overview

-#       This is a precursor for the vmware build system.

-#       This assumes that an empty hard disk is attached to the build VM.

-#       The path to this empty disk is specified in the HDD variable in config.inc

-#   End

-#

-grub_efi_install()

-{

-    mkdir $BUILDROOT/boot/efi