deleted file mode 100755

@@ -1,20 +0,0 @@

-#!/bin/sh

-

-dev_ram=/dev/ram1

-dir_needwrite=/fake/needwrite

-directory_list="var/log tmp "

-

-echo -e "Creating ext2fs on $dev_ram ...              \n"

-/sbin/mke2fs -m 0 -i 1024 -q $dev_ram > /dev/null 2>&1

-

-

-echo -e "Mounting ramdisk on $dir_needwrite ...         \n"

-mount -n $dev_ram $dir_needwrite

-

-for directory in $directory_list

-do

-mkdir -p $dir_needwrite/$directory

-echo -e "Created directory.. $directory on $dir_ramdisk \n"

-done

-

-

@@ -3,4 +3,4 @@ label install

 	menu label ^Install

 	menu default

 	kernel vmlinuz

-	append initrd=initrd.gz root=/dev/ram0 init=/linuxrc ramdisk_size=16384 loglevel=3

+	append initrd=initrd.img root=/dev/ram0 loglevel=3

deleted file mode 100755

@@ -1,103 +0,0 @@

-#!/bin/sh

-

-

-#ID is the volume id / label of the PHOTON boot CD that will be looked for.

-ID="PHOTON_VMWARE_CD"

-TMP_MOUNT="/mnt"

-

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

-

-#this script searches for cdrom devices and then tries to find

-#the PHOTON boot CD in order to mount it as / (rootfs)

-

-#you need following programs:

-#- /bin/sh (e.g. bash)

-#- echo

-#- [ (which is linked to test)

-#- mount

-#- umount

-#- grep

-#- pivot_root

-#- chroot

-

-#you need following devices:

-#- /dev/hd*, /dev/sd*, /dev/sr* or /dev/cdrom*

-#- /dev/null

-

-#you need following directories:

-#- /proc

-#- $TMP_MOUNT

-

-CHECK_TYPE="try_mount"

-

-if [ ! -d "/proc/" ]; then

-  mkdir /proc

-fi

-

-mount -n proc /proc -t proc

-

-#1. Create a list of possible cdrom devices.

-

-CDROM_LIST="/dev/sr0 /dev/sr1 /dev/cdrom /dev/hda /dev/hdb /dev/hdc /dev/hdd

-/dev/hde /dev/sda /dev/sdb"

-

-#2. now we try to find the PHOTON boot CD (we use ID as identification)

-

-PHOTON_CDROM_DEVICE=""

-echo "Using $CHECK_TYPE"

-for cdrom_device in $CDROM_LIST

-do

-  echo -n "Checking $cdrom_device ... "

-

-  if [ "$CHECK_TYPE" = "try_mount" ]; then

-    mount -n -t iso9660 $cdrom_device $TMP_MOUNT > /dev/null 2>&1

-    media_found=$?

-  fi

-

-  if [ $media_found -eq 0 ]; then

-

-    echo -n "media found"

-    if [ "$CHECK_TYPE" = "try_mount" ]; then

-      [ -e "$TMP_MOUNT/$ID" ]

-      media_photon=$?

-    fi

-

-    if [ "$CHECK_TYPE" = "try_mount" ]; then

-      umount -n $cdrom_device > /dev/null 2>&1

-    fi

-

-    if [ $media_photon -eq 0 ]; then

-      echo ", PHOTON boot CD found. Ready!"

-      PHOTON_CDROM_DEVICE="$cdrom_device"

-      break;

-    else

-      echo ", not PHOTON boot CD."

-    fi

-

-  else

-    echo "no media "

-  fi

-done

-

-

-#3. mount PHOTON CD as / (root fs)

-if [ "$PHOTON_CDROM_DEVICE" = "" ]; then

-

-  echo "No PHOTON boot CD found!!!  You will have to fix this to continue"

-  echo "do: mount -n -o ro -t iso9660 'your cd device' $TMP_MOUNT"

-  echo "Then exit shell to continue"

-  bash

-

-else

-

-  echo "Booting from $PHOTON_CDROM_DEVICE ...                  "

-

-  mount -n -o ro -t iso9660 $PHOTON_CDROM_DEVICE $TMP_MOUNT

-

-  cd $TMP_MOUNT

-  pivot_root . mnt

-  mount -t proc proc /proc 

-  exec /usr/sbin/chroot . sh -c 'umount /mnt/proc >/dev/null 2>&1;umount /mnt/dev;umount /mnt;exec -a init.new /lib/systemd/systemd' <dev/console > dev/console 2>&1

-#umount /mnt/proc;umount /mnt/dev;umount /mnt;exec -a init.new /sbin/init 3' <dev/console >dev/console 2>&1

-

-fi

@@ -1,6 +1,5 @@

 #	Editable variables follow

 BUILDROOT=/mnt/photon-root	# where to build photon

-PARENT="/usr/src/photon"	# where build syetm lives

 #	Edit partition and mnt_point for the correct values.

 #	Failing to do so will cause you grief as in overwriting your host system.

 #	You have been warned!

@@ -22,7 +22,7 @@ from window import Window

 from actionresult import ActionResult

 class Installer(object):

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

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

         self.install_config = install_config

         self.iso_installer = iso_installer

         self.tools_path = tools_path

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

         self.chroot_command = "./mk-run-chroot.sh"

         self.setup_grub_command = "./mk-setup-grub.sh"

         self.unmount_disk_command = "./mk-unmount-disk.sh"

-        self.local_install = local_install

-        print local_install

-        if local_install:

-            self.scripts_working_directory = "./"

-        elif self.iso_installer:

-            self.scripts_working_directory = "/usr/src/photon"

-        else:

-            self.scripts_working_directory = "./"

         if self.iso_installer:

-            self.photon_root = "/mnt/photon-root"

+            self.working_directory = "/mnt/photon-root"

         elif 'working_directory' in self.install_config:

-            self.photon_root = self.install_config['working_directory']

+            self.working_directory = self.install_config['working_directory']

         else:

-            self.photon_root = "/mnt/photon-root"

+            self.working_directory = "/mnt/photon-root"

+        self.photon_root = self.working_directory + "/photon-chroot";

-        self.photon_directory = self.photon_root + "/usr/src/photon"

         self.restart_command = "shutdown"

         self.hostname_file = self.photon_root + "/etc/hostname"

         self.hosts_file = self.photon_root + "/etc/hosts"

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

         else:

             self.output = None

+        self.install_factor = 3

         if self.iso_installer:

             #initializing windows

             self.maxy = maxy

@@ -102,15 +95,12 @@ class Installer(object):

     def unsafe_install(self, params):

-        self.prepare_files_rpms_list()

-

         if self.iso_installer:

             self.window.show_window()

-

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

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

             self.progress_bar.show()

-        self.pre_initialize_filesystem()

+        self.initialize_system()

         #install packages

         for rpm in self.rpms_tobeinstalled:

@@ -122,19 +112,17 @@ class Installer(object):

             return_value = self.install_package(rpm['package'])

             if return_value != 0:

                 self.exit_gracefully(None, None)

-            #time.sleep(0.05)

             if self.iso_installer:

                 self.progress_bar.increment(rpm['size'] * self.install_factor)

         if self.iso_installer:

             self.progress_bar.show_loading('Finalizing installation')

-        #finalize system

+

         self.finalize_system()

-        #time.sleep(5)

-        if not self.install_config['iso_system'] and not self.local_install:

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

             # install grub

-            process = subprocess.Popen([self.setup_grub_command, '-w', self.photon_root, self.install_config['disk']['disk'], self.install_config['disk']['root']], stdout=self.output,  stderr=self.output)

+            process = subprocess.Popen([self.setup_grub_command, '-w', self.photon_root, self.install_config['disk']['disk'], self.install_config['disk']['root']], stdout=self.output)

             retval = process.wait()

             #update root password

@@ -146,7 +134,7 @@ class Installer(object):

             #update openssh config

             self.update_openssh_config()

-        process = subprocess.Popen([self.unmount_disk_command, '-w', self.photon_root], stdout=self.output,  stderr=self.output)

+        process = subprocess.Popen([self.unmount_disk_command, '-w', self.photon_root], stdout=self.output)

         retval = process.wait()

         if self.iso_installer:

@@ -156,49 +144,17 @@ class Installer(object):

         return ActionResult(True, None)

-    def prepare_files_rpms_list(self):

-        self.total_size = 0

-        self.install_factor = 3

-

-        tools_list = (JsonWrapper("tools_list.json")).read()

-        tools = tools_list['base_tools']

-        # Add the additional iso tools.

-        if self.install_config['iso_system']:

-            tools = tools + tools_list['iso_tools'] + [self.rpm_path]

-

-        self.files_tobecopied = []

-        for item in tools:

-            src = os.path.join(self.scripts_working_directory, item)

-            if os.path.isfile(src):

-                if item != '.hidden':

-                    size = os.path.getsize(src)

-                    self.total_size += size

-                    self.files_tobecopied.append({'name': item, 'path': src, 'size': size})

-                continue

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

-                for name in files:

-                    file = os.path.join(root, name)

-                    size = os.path.getsize(file)

-                    self.total_size += size

-                    relative = None

-                    if name.endswith(".rpm"):

-                        relative = os.path.relpath(file, self.rpm_path)

-                        relative = os.path.join("RPMS", relative)

-                    self.files_tobecopied.append({'name': name, 'path': file, 'relative_path': relative, 'size': size})

-

-        # prepare the RPMs

-        # TODO: mbassiouny, do not copy the rpms twice

+    def copy_rpms(self):

+        # prepare the RPMs list

         rpms = []

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

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

             for name in files:

                 file = os.path.join(root, name)

                 size = os.path.getsize(file)

-                relative = os.path.relpath(file, self.rpm_path)

-                relative = os.path.join("RPMS", relative)

-                rpms.append({'name': name, 'path': file, 'relative_path': relative, 'size': size})

+                rpms.append({'name': name, 'path': file, 'size': size})

+        progressbar_num_items = 0

         self.rpms_tobeinstalled = []

-        # prepare the RPMs list

         selected_packages = self.install_config['packages']

         for package in selected_packages:

             pattern = package + '-[0-9]*.rpm'

@@ -206,69 +162,77 @@ class Installer(object):

                 if fnmatch.fnmatch(rpm['name'], pattern):

                     rpm['package'] = package

                     self.rpms_tobeinstalled.append(rpm)

-                    self.total_size += rpm['size'] + rpm['size'] * self.install_factor

+                    progressbar_num_items += rpm['size'] + rpm['size'] * self.install_factor

                     break

-    def copy_file(self, file):

-        if self.iso_installer:

-            message = 'Copying {0}...'.format(file['name'])

-            self.progress_bar.update_message(message)

-

-        if 'relative_path' in file and file['relative_path'] != None:

-            relative = file['relative_path']

-        else:

-            relative = os.path.relpath(file['path'], self.scripts_working_directory)

-

-        dst = os.path.join(self.photon_directory, relative)

-        if not os.path.exists(os.path.dirname(dst)):

-            os.makedirs(os.path.dirname(dst))

-        shutil.copy(file['path'], dst)

+        process = subprocess.Popen(['mkdir', '-p', self.photon_root + '/RPMS'], stdout=self.output)

+        retval = process.wait()

-    def copy_files(self):

-        for file in self.files_tobecopied:

-            self.copy_file(file)

-            #time.sleep(0.05)

-            if self.iso_installer:

-                self.progress_bar.increment(file['size'])

+        if self.iso_installer:

+            self.progress_bar.update_num_items(progressbar_num_items)

+        # Copy the rpms

         for rpm in self.rpms_tobeinstalled:

-            self.copy_file(rpm)

-            #time.sleep(0.05)

+            shutil.copy(rpm['path'], self.photon_root + '/RPMS/')

             if self.iso_installer:

                 self.progress_bar.increment(rpm['size'])

-    def pre_initialize_filesystem(self):

+    def copy_files(self):

+        # Make the photon_root directory if not exits

+        process = subprocess.Popen(['mkdir', '-p', self.photon_root], stdout=self.output)

+        retval = process.wait()

+

+        # Copy the installer files

+        process = subprocess.Popen(['cp', '-r', "../installer", self.photon_root], stdout=self.output)

+        retval = process.wait()

+

+        # get the RPMS dir form the cd

+        if self.rpm_path == 'cdrom':

+            # Mount the cd to get the RPMS

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

+            retval = process.wait()

+

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

+            retval = process.wait()

+            if retval != 0:

+                self.exit_gracefully(None, None)

+            self.rpm_path = '/mnt/cdrom/RPMS'

+            self.tools_path = '/mnt/cdrom'

+

+        self.copy_rpms()

+

+    def initialize_system(self):

         #Setup the disk

-        if (not self.install_config['iso_system']) and (not self.local_install):

-            process = subprocess.Popen([self.mount_command, '-w', self.photon_root, self.install_config['disk']['root']], stdout=self.output,  stderr=self.output)

+        if (not self.install_config['iso_system']):

+            process = subprocess.Popen([self.mount_command, '-w', self.photon_root, self.install_config['disk']['root']], stdout=self.output)

             retval = process.wait()

-        #Setup the filesystem basics

+        

         self.copy_files()

-        process = subprocess.Popen([self.prepare_command, '-w', self.photon_root, self.tools_path], stdout=self.output,  stderr=self.output)

+        

+        #Setup the filesystem basics

+        process = subprocess.Popen([self.prepare_command, '-w', self.photon_root, self.tools_path], stdout=self.output)

         retval = process.wait()

     def finalize_system(self):

         #Setup the disk

-        process = subprocess.Popen([self.chroot_command, '-w', self.photon_root, self.finalize_command, '-w', self.photon_root], stdout=self.output,  stderr=self.output)

+        process = subprocess.Popen([self.chroot_command, '-w', self.photon_root, self.finalize_command, '-w', self.photon_root], stdout=self.output)

         retval = process.wait()

         if self.iso_installer:

-            # just copy the initrd /boot -> /photon_mnt/boot

+            # just copy the initramfs /boot -> /photon_mnt/boot

             shutil.copy('/boot/initrd.img-no-kmods', self.photon_root + '/boot/')

-        elif not self.local_install:

-            #Build the initrd

-            process = subprocess.Popen([self.chroot_command, '-w', self.photon_root, './mkinitramfs', '-n', '/boot/initrd.img-no-kmods'],  stdout=self.output,  stderr=self.output)

-            retval = process.wait()

-            process = subprocess.Popen(["./mk-initrd", '-w', self.photon_root],  stdout=self.output,  stderr=self.output)

+        else:

+            #Build the initramfs

+            process = subprocess.Popen([self.chroot_command, '-w', self.photon_root, './mkinitramfs', '-n', '/boot/initrd.img-no-kmods'],  stdout=self.output)

             retval = process.wait()

     def install_package(self,  package_name):

         rpm_params = ''

-        if 'type' in self.install_config and (self.install_config['type'] in ['micro', 'minimal']):

+        if ('type' in self.install_config and (self.install_config['type'] in ['micro', 'minimal'])) or self.install_config['iso_system']:

             rpm_params = rpm_params + ' --excludedocs '

-        process = subprocess.Popen([self.chroot_command, '-w', self.photon_root, self.install_package_command, '-w', self.photon_root, package_name, rpm_params],  stdout=self.output,  stderr=self.output)

+        process = subprocess.Popen([self.chroot_command, '-w', self.photon_root, self.install_package_command, '-w', self.photon_root, package_name, rpm_params],  stdout=self.output)

         return process.wait()

     def replace_string_in_file(self,  filename,  search_string,  replace_string):

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

             os.chmod(self.authorized_keys_filename, 0600)

             # Change the sshd config to allow root login

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

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

             return process.wait()

@@ -17,12 +17,8 @@ from license import License

 class IsoInstaller(object):

-    def __init__(self, stdscreen, argv):

+    def __init__(self, stdscreen):

         self.screen = stdscreen

-        if len(argv) == 2:

-            local_install = True

-        else:

-            local_install = False

         # Init the colors

         curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)

@@ -41,15 +37,8 @@ class IsoInstaller(object):

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

-        # skip the disk selection and partitioning if we are running with conf file in test environment.

-        if local_install == True:

-            # Read the conf file

-            self.install_config = (JsonWrapper(argv[1])).read()

-            self.install_config['iso_system'] = False

-        else:

-            self.install_config['iso_system'] = False

-            disk_partitioner = DiskPartitioner(self.maxy, self.maxx)

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

+        self.install_config['iso_system'] = False

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

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

         custom_package_selector = CustomPackageSelector(self.maxy, self.maxx, self.install_config)

@@ -59,10 +48,12 @@ class IsoInstaller(object):

         root_password_reader = WindowStringReader(self.maxy, self.maxx, 10, 70, True,  'Set up root password',

             'Root password:', 

             2, self.install_config)

-        installer = Installer(self.install_config, self.maxy, self.maxx, True, local_install, tools_path="/usr/src/photon", rpm_path="/usr/src/photon/RPMS", log_path="/var/log")

+        installer = Installer(self.install_config, self.maxy, self.maxx, True, tools_path=None, rpm_path='cdrom', log_path="/var/log")

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

         items = [

+                    (license_agreement.display, False),

+                    (select_disk.display, True),

                     (package_selector.display, True),

                     (custom_package_selector.display, False),

                     (hostname_reader.get_user_string, True),

@@ -70,14 +61,6 @@ class IsoInstaller(object):

                     (installer.install, False)

                 ]

-        # Include disk selection and partitioning in state machine when there is no extra param.

-        if local_install == False:

-            items = [

-                        #(disk_partitioner.display, True),

-                        (select_disk.display, True)

-                    ] + items

-        items = [(license_agreement.display, False)] + items

-

         index = 0

         params = None

         while True:

@@ -94,7 +77,5 @@ class IsoInstaller(object):

                 if index < 0:

                     index = 0

-# Call this script without any parameter to install from iso

-# or pass a conf file to install on local sdb for testing.

 if __name__ == '__main__':

-    curses.wrapper(IsoInstaller, sys.argv)

+    curses.wrapper(IsoInstaller)

@@ -19,8 +19,7 @@ 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 ${PARENT} ]	&& fail "${PRGNAME}: PARENT not set: FAILURE"

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

+

 /sbin/ldconfig

 /usr/sbin/pwconv

 /usr/sbin/grpconv

deleted file mode 100755

@@ -1,68 +0,0 @@

-#!/bin/bash

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

-#       Title:  mk-initrd                       #

-#        Date:  2015-04-08                      #

-#     Version:  1.0                             #

-#      Author:  dthaluru@vmware.com             #

-#     Options:                                  #

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

-#	Overview

-#		Creates initial ramdisk

-#	End

-#

-

-source config.inc		#	configuration parameters

-source function.inc		#	commonn functions

-

-

-if [ -d ${BUILDROOT} ] ; then

-	[ -e ${BUILDROOT}/dev/ram0 ]    || mknod ${BUILDROOT}/dev/ram0 b 1 0

-	# Try to reduce this size to 8G or less later...maybe strip debug symbols off.

-	dd if=/dev/zero of=${BUILDROOT}/boot/initrd bs=1024 count=16384

-	mke2fs -m 0 -i 1024 -F ${BUILDROOT}/boot/initrd

-        mount -o loop ${BUILDROOT}/boot/initrd ${BUILDROOT}/mnt

-        cp BUILD_DVD/linuxrc ${BUILDROOT}/mnt/

-	cp BUILD_DVD/fstab ${BUILDROOT}/mnt/

-	pushd ${BUILDROOT}/mnt

-	mkdir bin lib dev proc mnt etc

-	ln -s lib lib64

-	ln -s bin sbin

-	popd

-	mknod ${BUILDROOT}/mnt/dev/ram0    b  1  0

-	mknod ${BUILDROOT}/mnt/dev/null    c  1  3

-	mknod ${BUILDROOT}/mnt/dev/zero    c  1  5

-	mknod ${BUILDROOT}/mnt/dev/console c  5  1

-	mknod ${BUILDROOT}/mnt/dev/ttyS0   c  4 64

-	mknod ${BUILDROOT}/mnt/dev/sr0     b 11  0

-	mknod ${BUILDROOT}/mnt/dev/sr1     b 11  1

-	mknod ${BUILDROOT}/mnt/dev/sda     b  8  0

-	mknod ${BUILDROOT}/mnt/dev/sdb     b  16  0

-	mknod ${BUILDROOT}/mnt/dev/sdc     b  32  0

-	mknod ${BUILDROOT}/mnt/dev/sdd     b  48  0

-	mknod ${BUILDROOT}/mnt/dev/hda     b  3  0

-	mknod ${BUILDROOT}/mnt/dev/hdb     b  3  64

-	mknod ${BUILDROOT}/mnt/dev/hdc     b  22  0

-	mknod ${BUILDROOT}/mnt/dev/hdd     b  22 64

-	mknod ${BUILDROOT}/mnt/dev/hde     b  33  0

-	cp ${BUILDROOT}/bin/{bash,mount,grep,umount,echo} ${BUILDROOT}/mnt/bin/

-	cp ${BUILDROOT}/usr/sbin/chroot ${BUILDROOT}/mnt/bin/

-	cp ${BUILDROOT}/sbin/pivot_root ${BUILDROOT}/mnt/bin/

-	ln -s bash ${BUILDROOT}/mnt/bin/sh

-	cp ${BUILDROOT}/lib/{libncursesw.so.*,libreadline.so.*} ${BUILDROOT}/mnt/lib/

-	cp ${BUILDROOT}/lib/{libhistory.so.*,libblkid.so.*,libuuid.so.*,libmount.so.*} ${BUILDROOT}/mnt/lib/

-	cp ${BUILDROOT}/usr/lib/libgcc_s.so.1 ${BUILDROOT}/mnt/lib/

-	ln -s libgcc_s.so.1 ${BUILDROOT}/mnt/lib/libgcc_s_so

-	for f in "ld-linux-x86-64.so.2" "libc.so.6" "libdl.so.2" "libpthread.so.0"

-	do

-		orig=$(readlink ${BUILDROOT}/lib/$f)

-    		orig_basename="${orig##*/}"

-    		cp ${BUILDROOT}/lib/$f ${BUILDROOT}/mnt/lib/$orig_basename

-		ln -sfv $orig_basename ${BUILDROOT}/mnt/lib/$f

-	done

-	cp ${BUILDROOT}/bin/{cat,sleep,mknod} ${BUILDROOT}/mnt/bin/

-	chmod 0755 ${BUILDROOT}/mnt/linuxrc

-	sleep 1

-	umount ${BUILDROOT}/mnt

-	gzip ${BUILDROOT}/boot/initrd

-fi

-

@@ -28,34 +28,25 @@ if [ $# -lt 2 ]

 fi

 ISO_OUTPUT_NAME=$1

 TOOLS_PATH=$2

-PACKAGE_LIST_FILE=$3

+RPMS_PATH=$3

+PACKAGE_LIST_FILE=$4

 #- Step 3 Setting up the boot loader

+WORKINGDIR=${BUILDROOT}

+BUILDROOT=${BUILDROOT}/photon-chroot

-mkdir ${BUILDROOT}/isolinux

-cp BUILD_DVD/isolinux/* ${BUILDROOT}/isolinux/

+mkdir ${WORKINGDIR}/isolinux

+cp BUILD_DVD/isolinux/* ${WORKINGDIR}/isolinux/

-mv ${BUILDROOT}/boot/* ${BUILDROOT}/isolinux/

-rmdir ${BUILDROOT}/boot

-ln -s isolinux ${BUILDROOT}/boot

+find ${BUILDROOT} -name linux-[0-9]*.rpm | head -1 | xargs rpm2cpio | cpio -iv --to-stdout ./boot/vmlinuz* > ${WORKINGDIR}/isolinux/vmlinuz

-find ${BUILDROOT} -name linux-[0-9]*.rpm | head -1 | xargs rpm2cpio | cpio -iv --to-stdout ./boot/vmlinuz* > ${BUILDROOT}/boot/vmlinuz

-

-cp -r ../installer ${BUILDROOT}/${PARENT}

+rm -f ${BUILDROOT}/installer/*.pyc

 # replace default package_list with specific one

-cp $PACKAGE_LIST_FILE ${BUILDROOT}/${PARENT}/installer/package_list.json

-rm -f ${BUILDROOT}/${PARENT}/installer/*.pyc

+cp $PACKAGE_LIST_FILE ${BUILDROOT}/installer/package_list.json

 #ID in the initrd.gz now is PHOTON_VMWARE_CD . This is how we recognize that the cd is actually ours. touch this file there.

-touch ${BUILDROOT}/PHOTON_VMWARE_CD

-

-#- Step 4 - Move /etc /var /root /home to /fake/needwrite

-

-mkdir -p ${BUILDROOT}/fake/{needwrite,ramdisk}

-mv ${BUILDROOT}/var/ ${BUILDROOT}/tmp ${BUILDROOT}/fake/needwrite/

-ln -s fake/needwrite/var ${BUILDROOT}/var

-ln -s fake/needwrite/tmp ${BUILDROOT}/tmp

+touch ${WORKINGDIR}/PHOTON_VMWARE_CD

 # Step 4.5 Create necessary devices

 mkfifo ${BUILDROOT}/dev/initctl

@@ -68,7 +59,6 @@ mknod ${BUILDROOT}/dev/sda b 8 0

 #- Step 5 - Creating the boot script

 mkdir -p ${BUILDROOT}/etc/systemd/scripts

-cp BUILD_DVD/create_ramdisk ${BUILDROOT}/bin/create_ramdisk

 # Step 6 create fstab

@@ -78,37 +68,55 @@ cp BUILD_DVD/fstab ${BUILDROOT}/etc/fstab

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

 #!/bin/bash

-create_ramdisk

-cd ${PARENT}/installer

+cd /installer

 ./isoInstaller.py 2> /var/log/installer && shutdown -r now

 /bin/bash

 EOF

 chmod 755 ${BUILDROOT}/bin/bootphotoninstaller

+cat >> ${BUILDROOT}/init << EOF

+mount -t proc proc /proc

+/lib/systemd/systemd

+EOF

+chmod 755 ${BUILDROOT}/init

+

 #adding autologin to the root user

 sed -i "s/ExecStart.*/ExecStart=-\/sbin\/agetty --autologin root --noclear %I $TERM/g" ${BUILDROOT}/lib/systemd/system/getty@.service

 sed -i "s/root:.*/root:x:0:0:root:\/root:\/bin\/bootphotoninstaller/g" ${BUILDROOT}/etc/passwd

-mkdir -p ${BUILDROOT}/mnt/photon-root

-cp $TOOLS_PATH/tools.tar.gz ${BUILDROOT}/${PARENT}/

+mkdir -p ${BUILDROOT}/mnt/photon-root/photon-chroot

+rm -rf ${BUILDROOT}/RPMS

+cp -r ${RPMS_PATH} ${WORKINGDIR}/

+cp $TOOLS_PATH/tools.tar.gz ${WORKINGDIR}/

 #creating rpm repo in cd..

-createrepo --database ${BUILDROOT}/${PARENT}/RPMS

+createrepo --database ${WORKINGDIR}/RPMS

-rm -rf ${BUILDROOT}/${PARENT}/LOGS

+rm -rf ${BUILDROOT}/LOGS

 #Remove our rpm database as it fills up the ramdisk

 rm -rf ${BUILDROOT}/var/lib/rpm

-find "$BUILDROOT"/{,usr/}lib -type f -exec strip --strip-debug '{}' ';' > /dev/null 2>&1

-find "$BUILDROOT"/{,usr/}{bin,sbin} -type f -exec strip --strip-unneeded '{}' ';' > /dev/null 2>&1

+# TODO: mbassiouny, Find a clean way to do that

+for i in `ls ${BUILDROOT}/usr/share/`; do

+	if [ $i != 'terminfo' -a $i != 'cracklib' -a $i != 'grub' ]; then

+		rm -rf ${BUILDROOT}/usr/share/$i

+	fi

+done

 rm -rf $BUILDROOT/tools

-#Step 9 Generate the ISO!!!!

+

+# Generate the intird

 pushd $BUILDROOT

+(find . | cpio -o -H newc --quiet | gzip -9 ) > ${WORKINGDIR}/isolinux/initrd.img

+popd

+rm -rf $BUILDROOT

+

+#Step 9 Generate the ISO!!!!

+pushd $WORKINGDIR

 mkisofs -R -l -L -D -b isolinux/isolinux.bin -c isolinux/boot.cat \

 		-no-emul-boot -boot-load-size 4 -boot-info-table -V "PHOTON_$(date +%Y%m%d)" \

-		$BUILDROOT >$ISO_OUTPUT_NAME

+		$WORKINGDIR >$ISO_OUTPUT_NAME

 popd

@@ -25,10 +25,8 @@ if [ $# -ge 2 ]

 fi

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

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

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

 RPMPKG=""

-RPMPKG=$(find RPMS -name "$1-[0-9]*.rpm" -print)

+RPMPKG=$(find ../RPMS -name "$1-[0-9]*.rpm" -print)

 [ -z $RPMPKG ] && fail "installation error: rpm package not found\n"

 case $1 in

 	linux-dev | linux-docs | glibc | gmp | gcc | bzip2 | ncurses | util-linux | e2fsprogs | shadow | bison | perl | texinfo | vim | linux | udev | rpm | dbus)

@@ -28,7 +28,6 @@ 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 ${PARENT} ]	&& fail "${PRGNAME}: PARENT not set: FAILURE"

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

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

@@ -50,7 +49,7 @@ if mountpoint ${BUILDROOT}/dev	>/dev/null 2>&1; then umount ${BUILDROOT}/dev; fi

     fi

     PATH=$PATH:/tools/bin

     }

-cd ${BUILDROOT}${PARENT}	|| fail "${PRGNAME}: Change directory: ${BUILDROOT}${PARENT}: FAILURE"

+cd ${BUILDROOT} || fail "${PRGNAME}: Change directory: ${BUILDROOT}: FAILURE"

 #

 #	Setup the filesystem for chapter 06

 #

@@ -19,7 +19,6 @@ 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 ${PARENT} ]	&& fail "${PRGNAME}: PARENT not set: FAILURE"

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

 # Remove the name of this script from our argument list

@@ -34,6 +33,6 @@ chroot "${BUILDROOT}" \

 	TERM="$TERM" \

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

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

-	/tools/bin/bash --login +h -c "cd ${PARENT};$*"

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

 exit 0

@@ -21,7 +21,6 @@ source function.inc		#	commonn functions

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

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

 ARCH=$(uname -m)	# host architecture

-RPMDIR=${PARENT}	# where rpms are stored on the host system

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

 > ${LOGFILE}		#	clear/initialize logfile

@@ -72,8 +71,7 @@ EOF

 sed -i "s/UUID_PLACEHOLDER/$UUID/" "$BUILDROOT"/boot/grub/grub.cfg > ${LOGFILE}	

 #Cleanup the workspace directory

-#find "$BUILDROOT"/{,usr/}{lib,bin,sbin} -type f -exec strip --strip-debug --strip-unneeded '{}' ';' > /dev/null 2>&1

 rm -rf "$BUILDROOT"/tools

-rm -rf "$BUILDROOT""$PARENT"

+rm -rf "$BUILDROOT"/RPMS

 #umount $BUILDROOT

@@ -19,7 +19,6 @@ 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 ${PARENT} ]	&& fail "${PRGNAME}: PARENT not set: FAILURE"

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

 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

@@ -88,6 +88,7 @@ if __name__ == '__main__':

     parser.add_option("-v", "--vmdk-path", dest="vmdk_path")

     parser.add_option("-w",  "--working-directory",  dest="working_directory", default="/mnt/photon-root")

     parser.add_option("-t",  "--tools-path",  dest="tools_path", default="../stage")

+    parser.add_option("-r",  "--rpm-path",  dest="rpm_path", default="../stage/RPMS")

     parser.add_option("-f", "--force", action="store_true", dest="force", default=False)

     parser.add_option("-p", "--package-list-file", dest="package_list_file", default="package_list.json")

@@ -164,12 +165,12 @@ if __name__ == '__main__':

     config['working_directory'] = options.working_directory

     # Run the installer

-    package_installer = Installer(config, local_install = not (options.iso_path or options.vmdk_path), tools_path = options.tools_path, rpm_path = options.tools_path + "/RPMS", log_path = options.tools_path + "/LOGS")

+    package_installer = Installer(config, tools_path = options.tools_path, rpm_path = options.rpm_path, log_path = options.tools_path + "/LOGS")

     package_installer.install(None)

     # Making the iso if needed

     if config['iso_system']:

-        process = subprocess.Popen(['./mk-install-iso.sh', '-w', options.working_directory, options.iso_path, options.tools_path, options.package_list_file])

+        process = subprocess.Popen(['./mk-install-iso.sh', '-w', options.working_directory, options.iso_path, options.tools_path, options.rpm_path, options.package_list_file])

         retval = process.wait()

     # Cleaning up for vmdk

@@ -31,14 +31,17 @@ class ProgressBar(object):

         self.panel.hide()

         panel.update_panels()

-    def initialize(self, num_items, init_message):

-        self.num_items = num_items

+    def initialize(self, init_message):

+        self.num_items = 0

         self.message = init_message

         self.time_elapsed = 0

         self.time_remaining = 60

         self.timer = threading.Timer(1, self.update_time)

         self.timer.start()

+    def update_num_items(self, num_items):

+        self.num_items = num_items

+

     def update_message(self, message):

         self.message = message

         self.render_message()

@@ -66,6 +69,8 @@ class ProgressBar(object):

         self.window.refresh()

     def render_progress(self):

+        if self.num_items == 0:

+            return

         completed = self.progress * 100 / self.num_items

         completed_width = completed * self.width / 100

         completed_str, remaining_str = self.get_spaces(completed_width, self.width, completed)