@@ -2,8 +2,8 @@ from CommandUtils import CommandUtils

 from ChrootUtils import ChrootUtils

 from Logger import Logger

 from PackageUtils import PackageUtils

-import shutil

 from constants import constants

+import subprocess

 class ToolChainUtils(object):

     __built_successfull=False

@@ -21,41 +21,69 @@ class ToolChainUtils(object):

         self.localegenConfig = "./locale-gen.conf"

         self.prepareBuildRootCmd="./prepare-build-root.sh"

-    def prepareChroot(self,chrootID,toolsArchive=None):

+    #Tool chain should be built before calling this method

+    def installToolChain(self,chrootID):

+        self.logger.info("Installing toolchain.....")

+        self.installCoreToolChainPackages(chrootID)

+        self.logger.info("Installed tool chain successfully on chroot:"+chrootID)

+    

+    def installCoreToolChainPackages(self,chrootID):

+        self.logger.info("Installing toolchain.....")

+        self.prepareBuildEnvironmentChroot(chrootID)

         cmdUtils=CommandUtils()

-        prepareChrootCmd=self.prepareBuildRootCmd+" "+chrootID+" "+constants.specPath+" "+constants.rpmPath+" "+constants.toolsPath

-        if toolsArchive is not None:

-            prepareChrootCmd=prepareChrootCmd+" "+toolsArchive

-        returnVal=cmdUtils.runCommandInShell(prepareChrootCmd)

-        if not returnVal:

-            self.logger.error("Prepare build root script failed.Unable to prepare chroot.")

-            raise Exception("Prepare build root script failed")

-

-        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/RPMS")

-        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/RPMS/x86_64")

-        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/RPMS/noarch")

-        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/SOURCES")

-        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/SPECS")

-        self.logger.info("Successfully prepared chroot:"+chrootID)

+        cmdUtils.runCommandInShell("rm "+ chrootID+"/"+constants.topDirPath+"/RPMS/x86_64/*")

+        cmdUtils.runCommandInShell("rm "+ chrootID+"/"+constants.topDirPath+"/RPMS/noarch/*")

+        self.logger.info("Installed core tool chain packages successfully on chroot:"+chrootID)    

+    

+    listToolChainRPMPkgs=["linux-api-headers", "glibc","glibc-devel",  "zlib","zlib-devel",  "file",

+            "binutils","binutils-devel",  "gmp","gmp-devel", "mpfr", "mpfr-devel", "mpc",

+            "libgcc","libgcc-devel","libstdc++","libstdc++-devel","libgomp","libgomp-devel","gcc",

+            "pkg-config", "ncurses", "bash", "bzip2", "sed","ncurses-devel","procps-ng","coreutils", "m4","grep",

+            "readline", "diffutils","gawk", "findutils", "gettext", "gzip","make",  "patch",

+            "util-linux", "tar", "xz","libtool", "flex",  "bison",

+            "readline-devel", "lua","lua-devel","popt","popt-devel","nspr","sqlite-autoconf","nss","nss-devel",

+            "bzip2-devel","elfutils-libelf","elfutils","elfutils-libelf-devel","elfutils-devel",

+            "expat","libffi","libpipeline", "gdbm","perl","texinfo","autoconf","automake",

+            "openssl","openssl-devel","python2","python2-libs","python2-devel","rpm",

+            "groff", "man-db", "man-pages","cpio"]

+    

+    def findRPMFileInGivenLocation(self,package,rpmdirPath):

+        cmdUtils = CommandUtils()

+        listFoundRPMFiles = cmdUtils.findFile(package+"-*.rpm",rpmdirPath)

+        listFilterRPMFiles=[]

+        for f in listFoundRPMFiles:

+            f1=f.replace(package,"")

+            print f1

+            l = f1.split("-")

+            print l

+            if len(l) == 3:

+                listFilterRPMFiles.append(f)

+        if len(listFilterRPMFiles) == 1 :

+            return listFilterRPMFiles[0]

+        if len(listFilterRPMFiles) == 0 :

+            return None

+        if len(listFilterRPMFiles) > 1 :

+            print("Found multiple rpm files for given package in rpm directory.Unable to determine the rpm file for package:"+package)

+            return None

     def buildCoreToolChainPackages(self):

         self.logger.info("Building core tool chain packages.....")

         chrootID=None

-        chrUtils = ChrootUtils(self.logName,self.logPath)

         try:

-            chrootName="build-core-toolchain"

-            returnVal,chrootID = chrUtils.createChroot(chrootName)

-            if not returnVal:

-                raise Exception("creating chroot failed")

-            self.prepareChroot(chrootID)

             pkgUtils=PackageUtils(self.logName,self.logPath)

             for package in constants.listCoreToolChainRPMPackages:

+                chrUtils = ChrootUtils(self.logName,self.logPath)

+                chrootName="build-core-toolchain"

+                returnVal,chrootID = chrUtils.createChroot(chrootName)

+                if not returnVal:

+                    self.logger.error("Creating chroot failed")

+                    raise Exception("creating chroot failed")

+                self.prepareBuildEnvironmentChroot(chrootID)

                 rpmPkg=pkgUtils.findRPMFileForGivenPackage(package)

                 if rpmPkg is None:

                     pkgUtils.buildRPMSForGivenPackage(package, chrootID)

-                pkgUtils.installRPM(package, chrootID, True)

-                if package == "glibc":

-                    self.adjustToolChain(chrootID)

+                chrUtils.destroyChroot(chrootID)

+                chrootID=None

             self.logger.info("Successfully built toolchain")

         except Exception as e:

             self.logger.error("Unable to build tool chain.")

@@ -63,58 +91,38 @@ class ToolChainUtils(object):

         finally:

             if chrootID is not None:

                 chrUtils.destroyChroot(chrootID)

-    

-    #Tool chain should be built before calling this method

-    def installToolChain(self,chrootID):

-        self.logger.info("Installing toolchain.....")

-        self.prepareChroot(chrootID,"minimal")

-        pkgUtils= PackageUtils(self.logName,self.logPath)

-        for package in constants.listToolChainRPMPkgs:

-            pkgUtils.installRPM(package, chrootID, True)

-        cmdUtils=CommandUtils()

-        cmdUtils.runCommandInShell("rm -rf "+ chrootID+"/tools")

-        cmdUtils.runCommandInShell("rm "+ chrootID+"/"+constants.topDirPath+"/RPMS/x86_64/*")

-        cmdUtils.runCommandInShell("rm "+ chrootID+"/"+constants.topDirPath+"/RPMS/noarch/*")

-        self.logger.info("Installed tool chain successfully on chroot:"+chrootID)

-    

-    def adjustToolChain(self,chrootID):

-        shutil.copy2(self.adjustToolChainScript,  chrootID+"/tmp")

-        shutil.copy2(self.localegenScript,  chrootID+"/sbin")

-        shutil.copy2(self.localegenConfig,  chrootID+"/etc")

-        cmdUtils=CommandUtils()

-        logFile=constants.logPath+"/adjustToolChainScript.log"

-        returnVal = cmdUtils.runCommandInShell("/tmp/"+self.adjustToolChainScript,logFile, "./run-in-chroot.sh "+chrootID)

+                

+    def prepareBuildEnvironmentChroot(self,chrootID):

+        self.logger.info("Preparing build environment")

+        previousVersionRPMSPath="/workspace1/testTP1RPMS/RPMS"

+        cmdUtils = CommandUtils()

+        prepareChrootCmd=self.prepareBuildRootCmd+" "+chrootID+" "+constants.specPath+" "+constants.rpmPath+" "+constants.logPath

+        logFile=constants.logPath+"/prepareBuildRoot.log"

+        returnVal=cmdUtils.runCommandInShell(prepareChrootCmd,logFile)

         if not returnVal:

-            self.logger.error("Adjust tool chain script failed.")

-            raise Exception("Adjust tool chain script failed")

-

-        

-    def installCoreToolChainPackages(self,chrootID):

-        self.logger.info("Installing toolchain.....")

-        self.prepareChroot(chrootID)

-        pkgUtils= PackageUtils(self.logName,self.logPath)

-        for package in constants.listCoreToolChainRPMPackages:

-            pkgUtils.installRPM(package, chrootID, True)

-            if package == "glibc":

-                self.adjustToolChain(chrootID)

-        cmdUtils=CommandUtils()

-        cmdUtils.runCommandInShell("rm "+ chrootID+"/"+constants.topDirPath+"/RPMS/x86_64/*")

-        cmdUtils.runCommandInShell("rm "+ chrootID+"/"+constants.topDirPath+"/RPMS/noarch/*")

-        self.logger.info("Installed core tool chain packages successfully on chroot:"+chrootID)    

-    

-    

-        

-    

-    

-    

-    

-

-    

-        

-        

-            

+            self.logger.error("Prepare build root script failed.Unable to prepare chroot.")

+            raise Exception("Prepare build root script failed")

+        for package in ToolChainUtils.listToolChainRPMPkgs:

+            pkgUtils=PackageUtils(self.logName,self.logPath)

+            rpmFile=pkgUtils.findRPMFileForGivenPackage(package)

+            if rpmFile is None:

+                rpmFile=self.findRPMFileInGivenLocation(package, previousVersionRPMSPath)

+                if rpmFile is None:

+                    self.logger.error("Unable to find rpm "+ package +" in current and previous versions")

+                    raise "Input Error"

+            self.logger.debug("Installing rpm:"+rpmFile)

+            cmd="rpm -i --nodeps --root "+chrootID+" --define \'_dbpath /var/lib/rpm\' "+ rpmFile

+            process = subprocess.Popen("%s" %cmd,shell=True,stdout=subprocess.PIPE)

+            retval = process.wait()

+            if retval != 0:

+                self.logger.error("Installing tool chain package "+package+" failed")

+                raise "RPM installation failed"

-    

-      

-

+        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/RPMS")

+        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/RPMS/x86_64")

+        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/RPMS/noarch")

+        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/SOURCES")

+        cmdUtils.runCommandInShell("mkdir -p "+chrootID+constants.topDirPath+"/SPECS")

+        self.logger.info("Successfully prepared chroot:"+chrootID)    

+    

\ No newline at end of file

@@ -43,10 +43,6 @@ def main():

     logger.info("Log Path :" + options.logPath)

     logger.info("Top Dir Path :" + options.topDirPath)

-    if not os.path.isfile(options.toolsPath+"/tools-build.tar"):

-        logger.error("Missing tools-build tar from tools path"+options.toolsPath)

-        logger.error("Please provide correct tools path and continue")

-        return False

     listPackages=["acl","attr","autoconf","automake","bash","bc","bindutils","binutils","bison","boost","btrfs-progs","bzip2","ca-certificates","cdrkit","check",

                   "cloud-init","cmake","coreutils","cpio","cracklib","createrepo","curl","cyrus-sasl","db","dbus","deltarpm","diffutils","docbook-xml","docbook-xsl",

@@ -10,53 +10,27 @@ set -o nounset

 set +h

 source common.inc

-LOGFILE="$(date +%Y-%m-%d).log"

-LOG_PATH=../../stage/LOGS

 PRGNAME=${0##*/}

-LOGFILE=$LOG_PATH/"${PRGNAME}-${LOGFILE}"

+

 if [ $# -lt 4 ]; then

-    fail "${PRGNAME}: No build root specified. Usage : ${PRGNAME} <build-root> <spec-path> <rpm-path> <tools-path>"

+    fail "${PRGNAME}: No build root specified. Usage : ${PRGNAME} <build-root> <spec-path> <rpm-path> <log-path>"

 fi

 #Clean up our build root first

 BUILDROOT=$1

 SPEC_PATH=$2

 RPM_PATH=$3

-TOOLS_PATH=$4

-TOOLS_ARCHIVE=""

-if [ $# -ge 5 ]; then

-    TOOLS_ARCHIVE=$5

-fi

+LOG_PATH=$4

 PARENT=/usr/src/photon

-rm -rf ${BUILDROOT}/*

-

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

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

-	echo "Creating directory: ${BUILDROOT}"

-	mkdir -p ${BUILDROOT}

-fi

+LOGFILE="$(date +%Y-%m-%d).log"

+LOGFILE=$LOG_PATH/"${PRGNAME}-${LOGFILE}"

 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

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

-

-#

-#Untar tools build to buildroot

-#

-

-if [ "x$TOOLS_ARCHIVE" = "xminimal" ] ; then

-    echo "Uncompressing the tools tar (minimal)"

-    tar -C ${BUILDROOT} -xzf $TOOLS_PATH/tools.tar.gz >/dev/null

-else

-    echo "Uncompressing the tools tar"

-    tar -C ${BUILDROOT} -xf $TOOLS_PATH/tools-build.tar >/dev/null

-fi

 mkdir -p ${BUILDROOT}/tmp

 mkdir -p ${BUILDROOT}${PARENT}

@@ -66,40 +40,28 @@ mkdir -p ${BUILDROOT}${PARENT}/BUILDROOT

 mkdir -p ${BUILDROOT}${PARENT}/LOGS

 mkdir -p ${BUILDROOT}${PARENT}/SOURCES

 mkdir -p ${BUILDROOT}${PARENT}/SPECS

+

 #copy localegen files.

 cp ./locale* ${BUILDROOT}${PARENT}/

 #copy kernel config files

 cp ./config* ${BUILDROOT}${PARENT}/

-

-

 #copy our macros and set the processor count

-NUMPROCS=`nproc`

-let NUMPROCS=$NUMPROCS+1

-echo "%_smp_mflags -j${NUMPROCS}" >> ${BUILDROOT}/tools/etc/rpm/macros

-

+#NUMPROCS=`nproc`

+#let NUMPROCS=$NUMPROCS+1

+#echo "%_smp_mflags -j${NUMPROCS}" >> ${BUILDROOT}/tools/etc/rpm/macros

 #	Setup the filesystem for chapter 06

 RPMPKG="$(find $RPM_PATH -name 'filesystem*.rpm' -print)"

 if [ -z ${RPMPKG} ] ; then

 run_command "	Extracting filesystem spec" "cp ${SPEC_PATH}/filesystem/filesystem.spec ${BUILDROOT}/${PARENT}/SPECS" "$LOG_PATH/filesystem.log"

-# rpmbuild requires /bin/bash

-run_command "	Creating symlink: /tools/bin /bin" "ln -fsv /tools/bin ${BUILDROOT}/bin"	 "$LOG_PATH/filesystem.completed"

-run_command "	Building filesystem rpm (in chroot)" "./run-in-chroot.sh ${BUILDROOT} rpmbuild -ba --nocheck --define \\\"_topdir ${PARENT}\\\" ${PARENT}/SPECS/filesystem.spec" "$LOG_PATH/filesystem.log"

-run_command "	Removing symlink: /tools/bin /bin" "rm -f ${BUILDROOT}/bin"	 "$LOG_PATH/filesystem.completed"

+run_command "	Building filesystem rpm " "rpmbuild -ba --nocheck --root ${BUILDROOT} --define \\\"_topdir ${PARENT}\\\" ${PARENT}/SPECS/filesystem.spec" "$LOG_PATH/filesystem.log"

 run_command "	Extracting filesystem rpm" "cp ${BUILDROOT}/${PARENT}/RPMS/x86_64/filesystem*.rpm ${RPM_PATH}/x86_64/" "$LOG_PATH/filesystem.log"

 fi

 RPMPKGFILE="$(find ${RPM_PATH} -name 'filesystem*.rpm' -printf %f)"

 [ -z ${RPMPKGFILE} ] && fail "	Filesystem rpm package missing: Can not continue"

-run_command "	Copying filesystem rpm" "cp ${RPM_PATH}/x86_64/${RPMPKGFILE} ${BUILDROOT}/${PARENT}/RPMS/x86_64" "$LOG_PATH/filesystem.log"

-run_command "	Installing filesystem (in chroot)" "./run-in-chroot.sh ${BUILDROOT} rpm -Uvh --nodeps ${PARENT}/RPMS/x86_64/${RPMPKGFILE}" "$LOG_PATH/filesystem.completed"

-run_command "	Creating symlinks: /tools/bin/{bash,cat,echo,pwd,stty}" "ln -fsv /tools/bin/{bash,cat,echo,pwd,stty} ${BUILDROOT}/bin"   "$LOG_PATH/filesystem.completed"

-run_command "	Creating symlinks: /tools/bin/perl /usr/bin" "ln -fsv /tools/bin/perl ${BUILDROOT}/usr/bin" "$LOG_PATH/filesystem.completed"

-run_command "	Creating symlinks: /tools/lib/libgcc_s.so{,.1}" "ln -fsv /tools/lib/libgcc_s.so{,.1} ${BUILDROOT}/usr/lib" "$LOG_PATH/filesystem.completed"

-run_command "	Creating symlinks: /tools/lib/libstdc++.so{,.6} /usr/lib" "ln -fsv /tools/lib/libstdc++.so{,.6} ${BUILDROOT}/usr/lib"	 "$LOG_PATH/filesystem.completed"

-[ -z $TOOLS_ARCHIVE ] && \

-    run_command "	Sed: /usr/lib/libstdc++.la" "sed 's/tools/usr/' ${BUILDROOT}/tools/lib/libstdc++.la > ${BUILDROOT}/usr/lib/libstdc++.la" "$LOG_PATH/filesystem.completed"

-run_command "	Creating symlinks: bash /bin/sh" "ln -fsv bash ${BUILDROOT}/bin/sh" "$LOG_PATH/filesystem.completed"

+run_command "	Installing filesystem " "rpm -Uvh --nodeps --root ${BUILDROOT} ${RPM_PATH}/x86_64/${RPMPKGFILE}" "$LOG_PATH/filesystem.completed"

+

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

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