@@ -56,7 +56,7 @@ clean-install clean-chroot build-updated-packages

 THREADS?=1

-all: iso minimal-iso docker-image ostree-host-iso live-iso cloud-image-all

+all: iso minimal-iso docker-image ostree-host-iso live-iso cloud-image-all src-iso

 micro: micro-iso

 	@:

@@ -164,12 +164,30 @@ iso: check $(PHOTON_STAGE) $(PHOTON_PACKAGES) ostree-repo

                 -w $(PHOTON_STAGE)/photon_iso \

                 -l $(PHOTON_STAGE)/LOGS \

                 -r $(PHOTON_STAGE)/RPMS \

+                -x $(PHOTON_STAGE)/SRPMS \

                 -p $(PHOTON_GENERATED_DATA_DIR)/$(FULL_PACKAGE_LIST_FILE) \

                 -o $(PHOTON_STAGE)/common/data \

                 -s $(PHOTON_DATA_DIR) \

                 -f > \

                 $(PHOTON_LOGS_DIR)/installer.log 2>&1

+src-iso: check $(PHOTON_STAGE) $(PHOTON_PACKAGES)

+	@echo "Building Photon Full Source ISO..."

+	@cd $(PHOTON_INSTALLER_DIR) && \

+        sudo $(PHOTON_INSTALLER) \

+                -j $(PHOTON_STAGE)/photon-$(PHOTON_RELEASE_VERSION)-$(PHOTON_BUILD_NUMBER).src.iso \

+                -w $(PHOTON_STAGE)/photon_iso \

+                -l $(PHOTON_STAGE)/LOGS \

+                -r $(PHOTON_STAGE)/RPMS \

+                -x $(PHOTON_STAGE)/SRPMS \

+                -p $(PHOTON_GENERATED_DATA_DIR)/$(FULL_PACKAGE_LIST_FILE) \

+                -o $(PHOTON_STAGE)/common/data \

+                -s $(PHOTON_DATA_DIR) \

+                -u $(PHOTON_DATA_DIR)/pkg_info.json\

+                -z $(PHOTON_STAGE)/pkg_info.txt\

+                -f > \

+                $(PHOTON_LOGS_DIR)/sourceiso-installer.log 2>&1

+

 pkgtree:

 	@cd $(PHOTON_SPECDEPS_DIR) && \

 		$(PHOTON_SPECDEPS) -s $(PHOTON_SPECS_DIR) -i pkg -p $(pkg)

@@ -198,6 +216,7 @@ packages: check $(PHOTON_STAGE) $(PHOTON_PUBLISH_RPMS) $(PHOTON_SOURCES) $(CONTA

                 -d $(PHOTON_DIST_TAG) \

                 -n $(PHOTON_BUILD_NUMBER) \

                 -v $(PHOTON_RELEASE_VERSION) \

+                -w $(PHOTON_DATA_DIR)/pkg_info.json\

                 $(PHOTON_RPMCHECK_OPTION) \

                 -t ${THREADS}

new file mode 100755

@@ -0,0 +1,45 @@

+#!/bin/bash

+#################################################

+#       Title:  mk-src-iso                      #

+#        Date:  2016-02-19                      #

+#     Version:  1.0                             #

+#      Author:  dthaluru@vmware.com             #

+#     Options:                                  #

+#################################################

+#	Overview

+#		Generates a photon source iso

+#	End

+#

+

+set +x                 # disable hashall

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

+source config.inc		#	configuration parameters

+source function.inc		#	commonn functions

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

+

+

+# Grab the name of the iso file 

+if [ $# -lt 2 ]

+then

+    echo "Usage : " $0 " <output-iso-with-path>  <srpms-path> <pkg-list-path>"

+    exit 1

+fi

+ISO_OUTPUT_NAME=$1

+SRPMS_PATH=$2

+SRPM_LIST=$3

+

+WORKINGDIR=${BUILDROOT}

+rm -r ${WORKINGDIR}/*

+(

+cd ${SRPMS_PATH}

+mkdir ${WORKINGDIR}/SRPMS

+for srpm_name in $SRPM_LIST; do

+    FILENAME="`find . -name "$srpm_name-[0-9]*" -type f`"

+    if [ -n "$FILENAME" ]; then

+        cp --parent $FILENAME ${WORKINGDIR}/SRPMS/;

+    fi

+done

+)

+

+mkisofs -r -o $ISO_OUTPUT_NAME $WORKINGDIR/

+

@@ -14,6 +14,7 @@ import sys

 import os

 from jsonwrapper import JsonWrapper

 from packageselector import PackageSelector

+import json

 def query_yes_no(question, default="no"):

     valid = {"yes": True, "y": True, "ye": True,

@@ -120,23 +121,43 @@ def get_live_cd_status_string(build_install_option):

                 return "true"

     return "false"

+def generate_pkginfo_text_file(list_rpms, pkg_info_json_file_path, pkg_info_text_file_path):

+    if not os.path.isfile(pkg_info_json_file_path):

+        return

+    pkg_info_json_file = open(pkg_info_json_file_path,'r')

+    data = json.load(pkg_info_json_file)

+    pkg_info_json_file.close()

+    list_lines = []

+    list_lines.append("#%{name},%{version},%{release},%{arch},%{sourcerpm}\n") 

+    for rpm in list_rpms:

+       if data.has_key(rpm):

+           list_lines.append(data[rpm]["name"]+","+data[rpm]["version"]+","+data[rpm]["release"]+","+data[rpm]["arch"]+","+data[rpm]["sourcerpm"]+"\n") 

+    pkg_info_text_file = open(pkg_info_text_file_path,'w')

+    pkg_info_text_file.writelines(list_lines)

+    pkg_info_text_file.close()

+

 if __name__ == '__main__':

     usage = "Usage: %prog [options] <config file> <tools path>"

     parser = OptionParser(usage)

     parser.add_option("-i", "--iso-path",  dest="iso_path")

+    parser.add_option("-j", "--src-iso-path",  dest="src_iso_path")

     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("-l",  "--log-path",  dest="log_path", default="../stage/LOGS")

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

+    parser.add_option("-x",  "--srpm-path",  dest="srpm_path", default="../stage/SRPMS")

     parser.add_option("-o", "--output-data-path", dest="output_data_path", default="../stage/common/data/")

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

     parser.add_option("-p", "--package-list-file", dest="package_list_file", default="../common/data/build_install_options_all.json")

     parser.add_option("-m", "--stage-path", dest="stage_path", default="../stage")

     parser.add_option("-c", "--dracut-configuration", dest="dracut_configuration_file", default="../common/data/dracut_configuration.json")

     parser.add_option("-s", "--json-data-path", dest="json_data_path", default="../stage/common/data/")

+    parser.add_option("-u", "--pkginfo-json-file", dest="pkginfo_json_file", default="../common/data/pkg_info.json")

+    parser.add_option("-z", "--pkginfo-txt-file", dest="pkginfo_txt_file", default="../stage/pkg_info.txt")

+

     (options,  args) = parser.parse_args()

-    if options.iso_path:

+    if options.iso_path or options.src_iso_path:

         # Check the arguments

         if (len(args)) != 0:

             parser.error("Incorrect arguments")

@@ -198,7 +219,7 @@ if __name__ == '__main__':

     config['packages'] = packages

-    if config['iso_system'] == True:

+    if options.iso_path:

         if os.path.isfile(options.dracut_configuration_file):

             json_wrapper_package_list = JsonWrapper(options.dracut_configuration_file)

             dracut_configuration_list_json = json_wrapper_package_list.read()

@@ -227,19 +248,27 @@ if __name__ == '__main__':

     package_installer.install(None)

     # Making the iso if needed

-    if config['iso_system']:

+    if options.iso_path:

         rpm_list = " ".join(create_rpm_list_to_copy_in_iso(options.package_list_file, options.output_data_path))

         files_to_copy = " ".join(create_additional_file_list_to_copy_in_iso(os.path.abspath(options.stage_path), options.package_list_file))

         live_cd = get_live_cd_status_string(options.package_list_file)

         process = subprocess.Popen(['./mk-install-iso.sh', '-w', options.working_directory, options.iso_path, options.rpm_path, options.package_list_file, rpm_list, options.stage_path, files_to_copy, live_cd, options.json_data_path])

         retval = process.wait()

+    if options.src_iso_path:

+        rpm_list = " ".join(create_rpm_list_to_copy_in_iso(options.package_list_file, options.output_data_path))

+        process = subprocess.Popen(['./mk-src-iso.sh', '-w', options.working_directory, options.src_iso_path, options.srpm_path, rpm_list])

+        retval = process.wait()

+        list_rpms = rpm_list.split(" ")

+        list_rpms = list(set(list_rpms))

+        generate_pkginfo_text_file(list_rpms, options.pkginfo_json_file, options.pkginfo_txt_file)

+

     # Cleaning up for vmdk

     if 'vmdk_install' in config and config['vmdk_install']:

         process = subprocess.Popen(['./mk-clean-vmdk.sh', config['disk']['disk']])

         process.wait()

     #Clean up the working directories

-    if (options.iso_path or options.vmdk_path):

+    if (options.iso_path or options.vmdk_path or options.src_iso_path):

         process = subprocess.Popen(['rm', '-rf', options.working_directory])

         retval = process.wait()

new file mode 100644

@@ -0,0 +1,44 @@

+import json

+from Logger import Logger

+from constants import constants

+import os.path

+from CommandUtils import CommandUtils

+

+class SourcePackageInfo(object):

+     sourcePkgList = {}

+     logger = None

+

+

+     @staticmethod

+     def setLogging(logName=None,logPath=None):

+        if logName is None:

+            logName = "SourcePackageInfo"

+        if logPath is None:

+            logPath = constants.logPath

+        SourcePackageInfo.logger=Logger.getLogger(logName,logPath)

+

+     @staticmethod

+     def loadPkgInfoFromFile(filePath):

+         SourcePackageInfo.logger.info("Loading source package list from the json file")

+         if not os.path.isfile(filePath):

+             return

+         pkgInfoFile = open(filePath,'r')

+         SourcePackageInfo.sourcePkgList = json.load(pkgInfoFile)

+         pkgInfoFile.close()

+

+     @staticmethod

+     def addSRPMData(packageName,version,release,arch,srpmFile):

+         listPkgAttributes={"name":packageName,"version":version,"release":release,"arch":arch,"sourcerpm":srpmFile}

+         SourcePackageInfo.sourcePkgList[packageName]=listPkgAttributes

+         SourcePackageInfo.logger.info("Added source package to the list:"+packageName)

+

+     @staticmethod

+     def writePkgListToFile(fileName):

+         SourcePackageInfo.logger.info("Writing source package list to the json file")

+         cmdUtils=CommandUtils()

+         dirPath=os.path.basename(fileName)

+         if not os.path.isdir(dirPath):

+             cmdUtils.runCommandInShell("mkdir -p "+dirPath)

+         pkgInfoFile = open(fileName,'w+')

+         json.dump(SourcePackageInfo.sourcePkgList, pkgInfoFile,indent=4)

+         pkgInfoFile.close()

@@ -6,6 +6,7 @@ from constants import constants

 import re

 from time import sleep

 import PullSources

+from PackageInfo import SourcePackageInfo

 class PackageUtils(object):

@@ -36,12 +37,16 @@ class PackageUtils(object):

         self.noDepsRPMFilesToInstallInAOneShot=""

         self.noDepsPackagesToInstallInAOneShot=""

-    def getRPMDestDir(self,rpmName,rpmDir):

+    def getRPMArch(self,rpmName):

         arch=""

         if rpmName.find("x86_64") != -1:

-            arch='x86_64'

+            arch="x86_64"

         elif rpmName.find("noarch") != -1:

             arch="noarch"

+        return arch

+

+    def getRPMDestDir(self,rpmName,rpmDir):

+        arch = self.getRPMArch(rpmName)

         rpmDestDir=rpmDir+"/"+arch

         return rpmDestDir

@@ -158,13 +163,19 @@ class PackageUtils(object):

         finally:

             if destLogPath is not None:

                 shutil.copy2(chrootLogsFilePath, destLogPath)

-

+        self.logger.info("RPM build is successful")

+        arch = self.getRPMArch(listRPMFiles[0])

+       

         for rpmFile in listRPMFiles:

             self.copyRPM(chrootID+"/"+rpmFile, constants.rpmPath)

-

+        

         for srpmFile in listSRPMFiles:

             self.copyRPM(chrootID+"/"+srpmFile, constants.sourceRpmPath)

+            srpmName = os.path.basename(srpmFile)

+            package,version,release = self.findPackageInfoFromSourceRPMFile(srpmFile)

+            SourcePackageInfo.addSRPMData(package,version,release,arch,srpmName)

+    

     def buildRPM(self,specFile,logFile,chrootCmd):

         rpmBuildcmd= self.rpmbuildBinary+" "+self.rpmbuildBuildallOption+" "+self.rpmbuildDistOption

@@ -242,7 +253,23 @@ class PackageUtils(object):

         version=rpmfile[versionindex+1:releaseindex]

         release=rpmfile[releaseindex+1:]

         return packageName,version,release

-    

+

+    def findPackageInfoFromSourceRPMFile(self,sourcerpmfile):

+        sourcerpmfile=os.path.basename(sourcerpmfile)

+        sourcerpmfile=sourcerpmfile.replace(".src.rpm","")

+        releaseindex=sourcerpmfile.rfind("-")

+        if releaseindex == -1:

+            self.logger.error("Invalid source rpm file:"+sourcerpmfile)

+            raise Exception("Invalid Source RPM")

+        versionindex=sourcerpmfile[0:releaseindex].rfind("-")

+        if versionindex == -1:

+            self.logger.error("Invalid source rpm file:"+sourcerpmfile)

+            raise Exception("Invalid source RPM")

+        packageName=sourcerpmfile[0:versionindex]

+        version=sourcerpmfile[versionindex+1:releaseindex]

+        release=sourcerpmfile[releaseindex+1:]

+        return packageName,version,release

+ 

     def findInstalledRPMPackages(self, chrootID):

         cmd = self.rpmBinary+" "+self.queryRpmPackageOptions

         chrootCmd=self.runInChrootCommand+" "+chrootID

@@ -49,9 +49,12 @@ class ToolChainUtils(object):

             cmd=self.rpmbuildCommand+" -ba --nocheck --define \'_topdir "+chrootID+constants.topDirPath+"\' --define \'_dbpath "+chrootID+"/var/lib/rpm\' --define \'dist "+constants.dist+"\' --define \'photon_build_number "+constants.buildNumber+"\' --define \'photon_release_version "+constants.releaseVersion+"\' "+specFile

             self.logger.info(cmd)

             cmdUtils.runCommandInShell(cmd,self.logPath+"/filesystem.log")

-            filesystemrpmFile = cmdUtils.findFile(package+"-*.rpm", chrootID+constants.topDirPath+"/RPMS")

+            filesystemrpmFile = cmdUtils.findFile(package+"-[0-9]*.rpm", chrootID+constants.topDirPath+"/RPMS")

+            filesystemsrpmFile = cmdUtils.findFile(package+"-[0-9]*.src.rpm", chrootID+constants.topDirPath+"/SRPMS")

             if len(filesystemrpmFile) > 0:

                 shutil.copy2(filesystemrpmFile[0],constants.rpmPath+"/x86_64/")

+            if len(filesystemsrpmFile) > 0:

+                shutil.copy2(filesystemsrpmFile[0],constants.sourceRpmPath+"/")

             rpmFile=pkgUtils.findRPMFileForGivenPackage(package)

             if rpmFile is None:

                 self.logger.error("Cannot find filesystem rpm")

@@ -12,6 +12,7 @@ from SpecUtils import Specutils

 from StringUtils import StringUtils

 import collections

 import traceback

+from PackageInfo import SourcePackageInfo

 def main():

     usage = "Usage: %prog [options] <package name>"

@@ -35,16 +36,18 @@ def main():

     parser.add_option("-v",  "--release-version", dest="releaseVersion",  default="NNNnNNN")

     parser.add_option("-u",  "--enable-rpmcheck", dest="rpmCheck",  default=False, action ="store_true")

     parser.add_option("-a",  "--source-rpm-path",  dest="sourceRpmPath",  default="../../stage/SRPMS")

+    parser.add_option("-w",  "--pkginfo-file",  dest="pkgInfoFile",  default="../../common/data/pkg_info.json")

     (options,  args) = parser.parse_args()

     cmdUtils=CommandUtils()

     if not os.path.isdir(options.logPath):

         cmdUtils.runCommandInShell("mkdir -p "+options.logPath)

-    

+

     logger=Logger.getLogger(options.logPath+"/Main")

     errorFlag=False

     package = None

+    pkgInfoJsonFile=options.pkgInfoFile

     if not os.path.isdir(options.sourcePath):

         logger.error("Given Sources Path is not a directory:"+options.sourcePath)

         errorFlag = True

@@ -102,25 +105,10 @@ def main():

     else:

         logger.info("Package to build:"+package)

-    '''    

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

-                  "docker","dracut","e2fsprogs","elfutils","etcd","expat","file","filesystem","findutils","flex","gawk","gcc","gdb","gdbm","gettext","git",

-                  "glib","glibc","glibmm","gmp","go","gobject-introspection","google-daemon","google-startup-scripts","gperf","gpgme","gptfdisk","grep","groff",

-                  "grub","gtk-doc","gzip","haveged","hawkey","iana-etc","inetutils","intltool","iproute2","iptables","itstool","json-glib","kbd","kmod","krb5",

-                  "kubernetes","less","libaio","libassuan","libcap","libdnet","libffi","libgpg-error","libgsystem","libhif","libmspack","libpcap","libpipeline",

-                  "librepo","libselinux","libsepol","libsigc++","libsolv","libtool","libxml2","libxslt","libyaml","linux","linux-api-headers","Linux-PAM","lua",

-                  "lvm2","lzo","m4","make","man-db","man-pages","mercurial","mpc","mpfr","nano","ncurses","nspr","nss","ntp","openldap","openssh","openssl",

-                  "open-vm-tools","ostree","parted","patch","pcre","perl","perl-common-sense","perl-Config-IniFiles","perl-DBD-SQLite","perl-DBI","perl-DBIx-Simple",

-                  "perl-Exporter-Tiny","perl-JSON-XS","perl-libintl","perl-List-MoreUtils","perl-Module-Install","perl-Module-ScanDeps","perl-Types-Serialiser",

-                  "perl-WWW-Curl","perl-YAML","perl-YAML-Tiny","photon-release","pkg-config","popt","procps-ng","psmisc","pycurl","pygobject","python2",

-                  "python-configobj","python-iniparse","python-jsonpatch","python-jsonpointer","python-prettytable","python-requests","python-setuptools",

-                  "python-six","PyYAML","readline","rocket","rpm","rpm-ostree","rpm-ostree-toolbox","ruby","sed","shadow","sqlite-autoconf","strace","sudo",

-                  "swig","systemd","tar","tcpdump","tcsh","tdnf","texinfo","thin-provisioning-tools","tzdata","unzip","urlgrabber","util-linux","vim","wget",

-                  "which","xerces-c","XML-Parser","xml-security-c","xz","yum","yum-metadata-parser","zlib"]

-    '''

     try:

         constants.initialize(options)

+        SourcePackageInfo.setLogging()

+        SourcePackageInfo.loadPkgInfoFromFile(pkgInfoJsonFile)

         if package == "packages_list":

             buildPackagesList(options.specPath, options.buildRootPath+"/../packages_list.csv")

         elif package == "sources_list":

@@ -141,7 +129,9 @@ def main():

         # print stacktrace

         traceback.print_exc()

         sys.exit(1)

-    

+

+    logger.info("Writing Package info to the file:"+pkgInfoJsonFile)

+    SourcePackageInfo.writePkgListToFile(pkgInfoJsonFile)   

     sys.exit(0)

 def buildToolChain(buildThreads):