@@ -146,10 +146,14 @@ iso: check $(PHOTON_STAGE) $(PHOTON_PACKAGES) ostree-repo

                 -f > \

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

-deptree:

+pkgtree:

 	@cd $(PHOTON_SPECDEPS_DIR) && \

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

+jsontree:

+	@cd $(PHOTON_SPECDEPS_DIR) && \

+		$(PHOTON_SPECDEPS) -s $(PHOTON_SPECS_DIR) -i json -f $(PHOTON_DATA_DIR)/build_install_options_$(json).json

+

 who-needs:

 	@cd $(PHOTON_SPECDEPS_DIR) && \

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

@@ -169,12 +173,12 @@ packages: check $(PHOTON_STAGE) $(PHOTON_PUBLISH_RPMS) $(PHOTON_SOURCES) $(CONTA

 		-d $(PHOTON_DIST_TAG) \

                 -t ${THREADS}

-build-updated-packages: check $(PHOTON_STAGE) $(PHOTON_PUBLISH_RPMS) $(PHOTON_SOURCES) $(CONTAIN) generate-dep-lists

+updated-packages: check $(PHOTON_STAGE) $(PHOTON_PUBLISH_RPMS) $(PHOTON_SOURCES) $(CONTAIN) generate-dep-lists

 	@echo "Building only updated RPMS..."

 	@cd $(PHOTON_PKG_BUILDER_DIR) && \

         $(PHOTON_PACKAGE_BUILDER) -o full \

                 -s $(PHOTON_SPECS_DIR) \

-                -r $(PHOTON_RPMS_DIR) \

+                -r $(PHOTON_UPDATED_RPMS_DIR) \

                 -x $(PHOTON_SRCS_DIR) \

                 -b $(PHOTON_CHROOT_PATH) \

                 -l $(PHOTON_LOGS_DIR) \

@@ -252,6 +256,9 @@ $(PHOTON_STAGE):

 	@echo "Building RPMS folders..."

 	@test -d $(PHOTON_RPMS_DIR_NOARCH) || $(MKDIR) -p $(PHOTON_RPMS_DIR_NOARCH)

 	@test -d $(PHOTON_RPMS_DIR_X86_64) || $(MKDIR) -p $(PHOTON_RPMS_DIR_X86_64)

+	@echo "Building UPDATED_RPMS folders..."

+	@test -d $(PHOTON_UPDATED_RPMS_DIR_NOARCH) || $(MKDIR) -p $(PHOTON_UPDATED_RPMS_DIR_NOARCH)

+	@test -d $(PHOTON_UPDATED_RPMS_DIR_X86_64) || $(MKDIR) -p $(PHOTON_UPDATED_RPMS_DIR_X86_64)

 	@echo "Building SOURCES folder..."

 	@test -d $(PHOTON_SRCS_DIR) || $(MKDIR) -p $(PHOTON_SRCS_DIR)

 	@echo "Building LOGS folder..."

@@ -22,55 +22,55 @@ class SerializableSpecObject(object):

 class SerializedSpecObjects(object):

-    def __init__(self, inputDataDir, stageDir):

-        self.mapSerializableSpecObjects={}

-        self.mapPackageToSpec={}

-	self.jsonFilesOutPath = stageDir + "/common/data/"

-	self.inputDataDir = inputDataDir

+	def __init__(self, inputDataDir, stageDir):

+		self.mapSerializableSpecObjects={}

+		self.mapPackageToSpec={}

+		self.jsonFilesOutPath = stageDir + "/common/data/"

+		self.inputDataDir = inputDataDir

-    def findTotalRequires(self, allDeps, depQue, parent, displayOption):

-        

-        while not depQue.empty():

-		specPkg = depQue.get()

-                specName = self.getSpecName(specPkg) 

-		specObj = self.mapSerializableSpecObjects[specName]

-		for depPkg in specObj.installRequiresPackages[specPkg]:

-			if True == allDeps.has_key(depPkg): 

-				if(allDeps[depPkg] < allDeps[specPkg] + 1): 

+	def findTotalRequires(self, allDeps, depQue, parent, displayOption):

+		while not depQue.empty():

+			specPkg = depQue.get()

+			specName = self.getSpecName(specPkg)

+			specObj = self.mapSerializableSpecObjects[specName]

+			for depPkg in specObj.installRequiresPackages[specPkg]:

+				if True == allDeps.has_key(depPkg): 

+					if(allDeps[depPkg] < allDeps[specPkg] + 1): 

+						allDeps[depPkg] = allDeps[specPkg] + 1

+						parent[depPkg] = specPkg

+						self.updateLevels(allDeps, depPkg, parent, allDeps[depPkg])

+				else:

 					allDeps[depPkg] = allDeps[specPkg] + 1

 					parent[depPkg] = specPkg

-					self.updateLevels(allDeps, depPkg, parent, allDeps[depPkg])

-			else:

-				allDeps[depPkg] = allDeps[specPkg] + 1

-				parent[depPkg] = specPkg

-				depQue.put(depPkg)

+					depQue.put(depPkg)

-    def printTree(self, allDeps, children, curParent , depth):    

+	def printTree(self, allDeps, children, curParent , depth):    

 		if (children.has_key(curParent)):

 			for child in children[curParent]:

 				print "\t" * depth, child

 				self.printTree(allDeps, children, child, depth+1)

-    def get_all_package_names(self, jsonFilePath):

-    	base_path = os.path.dirname(jsonFilePath)

-    	jsonData = open(jsonFilePath)

-    	option_list_json = json.load(jsonData)

-    	jsonData.close()

-    	packages = option_list_json["packages"]

-    	return packages

+	def get_all_package_names(self, jsonFilePath):

+		base_path = os.path.dirname(jsonFilePath)

+		jsonData = open(jsonFilePath)

+		option_list_json = json.load(jsonData)

+		jsonData.close()

+		packages = option_list_json["packages"]

+		return packages

-    def updateLevels(self, allDeps, inPkg, parent, level):

-        specName = self.getSpecName(inPkg) 

-        specObj  = self.mapSerializableSpecObjects[specName]

-        for depPkg in specObj.installRequiresPackages[inPkg]:

-		if (allDeps.has_key(depPkg) and allDeps[depPkg] < level + 1): 

-	   		allDeps[depPkg] = level + 1

-			parent[depPkg] = inPkg

+	def updateLevels(self, allDeps, inPkg, parent, level):

+		specName = self.getSpecName(inPkg) 

+		specObj  = self.mapSerializableSpecObjects[specName]

+		for depPkg in specObj.installRequiresPackages[inPkg]:

+			if (allDeps.has_key(depPkg) and allDeps[depPkg] < level + 1): 

+				allDeps[depPkg] = level + 1

+				parent[depPkg] = inPkg

-    def readSpecsAndConvertToSerializableObjects(self, specFilesPath, inputType, inputValue, displayOption):

+	def readSpecsAndConvertToSerializableObjects(self, specFilesPath, inputType, inputValue, displayOption):

 		children = {}

 		listSpecFiles=[]

 		whoNeedsList=[]

+		independentRPMS=[] # list of all RPMS not built from photon and that must be blindly copied.

 		allDeps={}

 		parent={}

 		depQue = Queue.Queue()

@@ -92,124 +92,146 @@ class SerializedSpecObjects(object):

 			specObj.securityHardening=spec.getSecurityHardeningOption()

 			for specPkg in specObj.listPackages:

 				specObj.installRequiresPackages[specPkg]=spec.getRequires(specPkg)

-				if( inputType == "pkg" and inputValue == specPkg): # all all the first level dependencies to a dictionary and queue 

-				    packageFound = True

-				    for depPkg in specObj.installRequiresPackages[specPkg]:

-					if False == allDeps.has_key(depPkg):

-								allDeps[depPkg] = 0

-								parent[depPkg] = ""

-								depQue.put(depPkg)

-				if (inputType == "who-needs"):

-					if (inputValue in specObj.installRequiresPackages[specPkg]):

-						whoNeedsList.append(specPkg)

+				if (inputType == "pkg" and inputValue == specPkg): # all the first level dependencies to a dictionary and queue 

+					packageFound = True

+					for depPkg in specObj.installRequiresPackages[specPkg]:

+						if False == allDeps.has_key(depPkg):

+							allDeps[depPkg] = 0

+							parent[depPkg] = ""

+							depQue.put(depPkg)

+				if (inputType == "who-needs" and (inputValue in specObj.installRequiresPackages[specPkg])):

+					whoNeedsList.append(specPkg)

 				self.mapPackageToSpec[specPkg]=specName

 			self.mapSerializableSpecObjects[specName]=specObj		

+	    

+		# Generate dependencies for individual packages

 		if (inputType == "pkg"):

 			if (packageFound == True):

 				self.findTotalRequires(allDeps, depQue, parent, displayOption)

 			else:

 				print "No spec file builds a package named",inputValue

-  	  			return

+				return

+

+		# Generate dependencies for all packages in the given JSON input file

 		elif (inputType == "json"):

 			filePath = self.inputDataDir +"/"+ inputValue

 			data = self.get_all_package_names(filePath)

-			#print data

 			for pkg in data:

 				if False == allDeps.has_key(pkg):

-					allDeps[pkg] = 0 

-					parent[pkg] = ""

-					depQue.put(pkg)

-					self.findTotalRequires(allDeps, depQue, parent, displayOption)

+					spName = self.getSpecName(pkg)

+					if(spName != None):			

+						allDeps[pkg] = 0 

+						parent[pkg] = ""

+						depQue.put(pkg)

+						self.findTotalRequires(allDeps, depQue, parent, displayOption)

+					else:

+						independentRPMS.append(pkg); 

+

+		#Generating the list of packages that requires the given input package at install time

 		elif (inputType == "who-needs"):

 			print whoNeedsList

+			return

+

 		# construct the sorted list of all packages (sorted by dependency)

 		sortedList = []

 		for elem in sorted(allDeps.items(), key=operator.itemgetter(1), reverse=True):

 			sortedList.append(elem[0])

-		# construct all children nodes

+		sortedList.extend(independentRPMS)

+

+	    # construct all children nodes

 		if (displayOption == "tree"):

-			#print "parent:" ,parent

 			for k, v in parent.iteritems():

 				children.setdefault(v, []).append(k)

 			if(inputType == "json"):

-				print "Dependency Mappings:\n", children

+				print "Dependency Mappings for", inputValue, ":", "\n----------------------------------------------------",children

+				print "----------------------------------------------------"				

 			if (children.has_key("")):

 				for child in children[""]:

 					print child

 					self.printTree(allDeps, children, child, 1)

+				for pkg in independentRPMS:

+					print pkg

+				print "******************",len(sortedList), "packages in total ******************"

 			else:

 				if (inputType == "pkg" and len(children) > 0):

-					print "cyclic dependency mappings: \n",children

+					print "cyclic dependency detected, mappings: \n",children 

+

+		# To display a flat list of all packages

 		elif(displayOption == "list"):

 			print sortedList

+

+		# To generate a new JSON file based on given input json file

 		elif(displayOption == "json" and inputType == "json"):

 			d = {}

 			d['packages'] = sortedList

 			outFilePath = self.jsonFilesOutPath + inputValue

 			with open(outFilePath, 'wb') as outfile:

-    				json.dump(d, outfile)		

+				json.dump(d, outfile)		

-    def getListSpecFiles(self,listSpecFiles,path):

-        for dirEntry in os.listdir(path):

-            dirEntryPath = os.path.join(path, dirEntry)

-            if os.path.isfile(dirEntryPath) and dirEntryPath.endswith(".spec"):

-                listSpecFiles.append(dirEntryPath)

-            elif os.path.isdir(dirEntryPath):

-                self.getListSpecFiles(listSpecFiles,dirEntryPath)

+	def getListSpecFiles(self,listSpecFiles,path):

+		for dirEntry in os.listdir(path):

+			dirEntryPath = os.path.join(path, dirEntry)

+			if os.path.isfile(dirEntryPath) and dirEntryPath.endswith(".spec"):

+				listSpecFiles.append(dirEntryPath)

+			elif os.path.isdir(dirEntryPath):

+				self.getListSpecFiles(listSpecFiles,dirEntryPath)

-    def getBuildRequiresForPackage(self, package):

-        specName=self.getSpecName(package)

-        return self.mapSerializableSpecObjects[specName].buildRequirePackages

+	def getBuildRequiresForPackage(self, package):

+		specName=self.getSpecName(package)

+		return self.mapSerializableSpecObjects[specName].buildRequirePackages

-    def getRequiresForPackage(self, package):

-        specName=self.getSpecName(package)

-        if self.mapSerializableSpecObjects[specName].installRequiresPackages.has_key(package):

-            return self.mapSerializableSpecObjects[specName].installRequiresPackages[package]

-        return None

+	def getRequiresForPackage(self, package):

+		specName=self.getSpecName(package)

+		if self.mapSerializableSpecObjects[specName].installRequiresPackages.has_key(package):

+			return self.mapSerializableSpecObjects[specName].installRequiresPackages[package]

+		return None

-    def getRelease(self, package):

-        specName=self.getSpecName(package)

-        return self.mapSerializableSpecObjects[specName].release

+	def getRelease(self, package):

+		specName=self.getSpecName(package)

+		return self.mapSerializableSpecObjects[specName].release

-    def getVersion(self, package):

-        specName=self.getSpecName(package)

-        return self.mapSerializableSpecObjects[specName].version

+	def getVersion(self, package):

+		specName=self.getSpecName(package)

+		return self.mapSerializableSpecObjects[specName].version

-    def getSpecFile(self, package):

-        specName=self.getSpecName(package)

-        return self.mapSerializableSpecObjects[specName].specFile

+	def getSpecFile(self, package):

+		specName=self.getSpecName(package)

+		return self.mapSerializableSpecObjects[specName].specFile

-    def getPatches(self, package):

-        specName=self.getSpecName(package)

-        return self.mapSerializableSpecObjects[specName].listPatches

+	def getPatches(self, package):

+		specName=self.getSpecName(package)

+		return self.mapSerializableSpecObjects[specName].listPatches

-    def getSources(self, package):

-        specName=self.getSpecName(package)

-        return self.mapSerializableSpecObjects[specName].listSources

+	def getSources(self, package):

+		specName=self.getSpecName(package)

+		return self.mapSerializableSpecObjects[specName].listSources

-    def getPackages(self, package):

-        specName=self.getSpecName(package)

-        return self.mapSerializableSpecObjects[specName].listPackages

+	def getPackages(self, package):

+		specName=self.getSpecName(package)

+		return self.mapSerializableSpecObjects[specName].listPackages

-    def getSpecName(self,package):

-        if self.mapPackageToSpec.has_key(package):

-            specName=self.mapPackageToSpec[package]

-            if self.mapSerializableSpecObjects.has_key(specName):

-                return specName

-        print "SpecDeps: Could not able to find "+package+" package from specs"

-        raise Exception("Invalid package:"+package)

+	def getSpecName(self,package):

+		if self.mapPackageToSpec.has_key(package):

+			specName=self.mapPackageToSpec[package]

+			if self.mapSerializableSpecObjects.has_key(specName):

+				return specName

+			else:

+				print "SpecDeps: Could not able to find " + package + " package from specs"

+				raise Exception("Invalid package:" + package)

+		else:

+			return None			

-    def isRPMPackage(self,package):

-        if self.mapPackageToSpec.has_key(package):

-            specName=self.mapPackageToSpec[package]

-            if self.mapSerializableSpecObjects.has_key(specName):

-                return True

-        return False

+	def isRPMPackage(self,package):

+		if self.mapPackageToSpec.has_key(package):

+			specName=self.mapPackageToSpec[package]

+			if self.mapSerializableSpecObjects.has_key(specName):

+				return True

+		return False

-    def getSecurityHardeningOption(self, package):

-        specName=self.getSpecName(package)

-        return self.mapSerializableSpecObjects[specName].securityHardening

+	def getSecurityHardeningOption(self, package):

+		specName=self.getSpecName(package)

+		return self.mapSerializableSpecObjects[specName].securityHardening

-    def getSpecDetails(self, name):

-    	print self.mapSerializableSpecObjects[name].installRequiresAllPackages 

+	def getSpecDetails(self, name):

+		print self.mapSerializableSpecObjects[name].installRequiresAllPackages 

@@ -29,30 +29,27 @@ def main():

 	parser.add_option("-a", "--input-data-dir", dest="input_data_dir", default="../../common/data/")

 	(options,  args) = parser.parse_args() 

-

 	if(False == options.input_data_dir.endswith('/')):

 		options.input_data_dir += '/'

-	

-		

 	specDeps = SerializedSpecObjects(options.input_data_dir, options.stage_dir)

 	displayOption = options.display_option

 	abs_path = os.path.abspath(__file__)

 	dir_name = os.path.dirname(abs_path)

 	os.chdir(dir_name)

-	

+

 	if(options.input_type == "pkg" or options.input_type == "who-needs"): # To display/print package dependencies on console

 		targetName = options.pkg

 		specDeps.readSpecsAndConvertToSerializableObjects(options.spec_dir, options.input_type, targetName, displayOption)

-	elif(options.input_type == "json"):

-		 # Generate the expanded package dependencies json file based on package_list_file 

+	elif(options.input_type == "json"):# Generate the expanded package dependencies json file based on package_list_file 

 		json_wrapper_option_list = JsonWrapper(options.json_file)

 		option_list_json = json_wrapper_option_list.read()

 		options_sorted = option_list_json.items()

 		for install_option in options_sorted:

-			if install_option[1]["file"] != "iso":

-				specDeps.readSpecsAndConvertToSerializableObjects(options.spec_dir, options.input_type, install_option[1]["file"], displayOption)

-	

+			if displayOption == "tree" and install_option[1]["title"] == "ISO Packages":

+				continue

+			specDeps.readSpecsAndConvertToSerializableObjects(options.spec_dir, options.input_type, install_option[1]["file"], displayOption)

+

 	sys.exit(0)

 if __name__=="__main__":

@@ -21,6 +21,7 @@ MAKEROOT := $(realpath $(MAKEROOT))

 PHOTON_STAGE?=$(SRCROOT)/stage

 PHOTON_LOGS_DIR=$(PHOTON_STAGE)/LOGS

 PHOTON_RPMS_DIR=$(PHOTON_STAGE)/RPMS

+PHOTON_UPDATED_RPMS_DIR?=$(PHOTON_STAGE)/UPDATED_RPMS

 PHOTON_SPECS_DIR?=$(SRCROOT)/SPECS

 PHOTON_COMMON_DIR?=$(SRCROOT)/common

 PHOTON_DATA_DIR?=$(PHOTON_COMMON_DIR)/data

@@ -44,6 +45,8 @@ PHOTON_CLOUD_IMAGE_BUILDER=$(PHOTON_CLOUD_IMAGE_BUILDER_DIR)/cloud-image-build.s

 PHOTON_CHROOT_CLEANER=$(PHOTON_PKG_BUILDER_DIR)/cleanup-build-root.sh

 PHOTON_RPMS_DIR_NOARCH=$(PHOTON_RPMS_DIR)/noarch

 PHOTON_RPMS_DIR_X86_64=$(PHOTON_RPMS_DIR)/x86_64

+PHOTON_UPDATED_RPMS_DIR_NOARCH?=$(PHOTON_UPDATED_RPMS_DIR)/noarch

+PHOTON_UPDATED_RPMS_DIR_X86_64?=$(PHOTON_UPDATED_RPMS_DIR)/x86_64

 PHOTON_PACKER_TEMPLATES=$(SRCROOT)/support/packer-templates

 PHOTON_CHROOT_PATH:=$(PHOTON_STAGE)/photonroot