@@ -8,10 +8,10 @@

 class Action(object):

     def do_action(self, params):

-    	raise NameError('Abstract method, this should be implemented in the child class')

+        raise NameError('Abstract method, this should be implemented in the child class')

     def hide(self, params):

-    	raise NameError('Abstract method, this should be implemented in the child class')

+        raise NameError('Abstract method, this should be implemented in the child class')

@@ -7,9 +7,9 @@ enabled = True

 def execute(name, ks_config, config, root):

-	if ks_config:

-		if 'partitions' in ks_config:

-			partitions = ks_config['partitions']

-		else:

-			partitions = commons.default_partitions

-		config['disk'] = commons.partition_disk(ks_config['disk'], partitions)

+    if ks_config:

+        if 'partitions' in ks_config:

+            partitions = ks_config['partitions']

+        else:

+            partitions = commons.default_partitions

+        config['disk'] = commons.partition_disk(ks_config['disk'], partitions)

@@ -10,7 +10,7 @@ def execute(name, ks_config, config, root):

     if ks_config and 'postinstall' in ks_config:

         config['postinstall'] = ks_config['postinstall']

     if 'postinstall' not in config:

-    	return

+        return

     # run the script in the chroot environment

     script = config['postinstall']

@@ -20,6 +20,6 @@ def execute(name, ks_config, config, root):

     hosts_file = os.path.join(root, 'etc/hosts')

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

-    	outfile.write(hostname)

+        outfile.write(hostname)

     commons.replace_string_in_file(hosts_file, r'127\.0\.0\.1\s+localhost\s*\Z', '127.0.0.1\tlocalhost\n127.0.0.1\t' + hostname)

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

 class SerializedSpecObjects(object):

-	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): 

-						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)

-	

-	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 __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): 

+                        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)

+    

+    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 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

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

-			                 

-	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()

-		packageFound = False

-		self.getListSpecFiles(listSpecFiles,specFilesPath)

-		for specFile in listSpecFiles:

-			spec=Specutils(specFile)

-			specName=spec.getBasePackageName()

-			specObj=SerializableSpecObject()

-			specObj.name=specName

-			specObj.buildRequirePackages=spec.getBuildRequiresAllPackages()

-			specObj.installRequiresAllPackages=spec.getRequiresAllPackages()

-			specObj.listPackages=spec.getPackageNames()

-			specObj.specFile=specFile

-			specObj.version=spec.getVersion()

-			specObj.release=spec.getRelease()

-			specObj.listSources=spec.getSourceNames()

-			specObj.listPatches=spec.getPatchNames()

-			specObj.securityHardening=spec.getSecurityHardeningOption()

-			for specPkg in specObj.listPackages:

-				specObj.installRequiresPackages[specPkg]=spec.getRequires(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

+    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

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

+                             

+    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()

+        packageFound = False

+        self.getListSpecFiles(listSpecFiles,specFilesPath)

+        for specFile in listSpecFiles:

+            spec=Specutils(specFile)

+            specName=spec.getBasePackageName()

+            specObj=SerializableSpecObject()

+            specObj.name=specName

+            specObj.buildRequirePackages=spec.getBuildRequiresAllPackages()

+            specObj.installRequiresAllPackages=spec.getRequiresAllPackages()

+            specObj.listPackages=spec.getPackageNames()

+            specObj.specFile=specFile

+            specObj.version=spec.getVersion()

+            specObj.release=spec.getRelease()

+            specObj.listSources=spec.getSourceNames()

+            specObj.listPatches=spec.getPatchNames()

+            specObj.securityHardening=spec.getSecurityHardeningOption()

+            for specPkg in specObj.listPackages:

+                specObj.installRequiresPackages[specPkg]=spec.getRequires(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

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

-			for pkg in data:

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

-					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); 

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

+            for pkg in data:

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

+                    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

+        #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])

-		sortedList.extend(independentRPMS)

+        # 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])

+        sortedList.extend(independentRPMS)

-	    # construct all children nodes

-		if (displayOption == "tree"):

-			for k, v in parent.iteritems():

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

-			if(inputType == "json"):

-				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 detected, mappings: \n",children 

+        # construct all children nodes

+        if (displayOption == "tree"):

+            for k, v in parent.iteritems():

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

+            if(inputType == "json"):

+                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 detected, mappings: \n",children 

-		# To display a flat list of all packages

-		elif(displayOption == "list"):

-			print sortedList

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

-	

-	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)

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

+    

+    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

-			else:

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

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

-		else:

-			return None			

+    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 

@@ -18,39 +18,39 @@ LOG_FILE_DIR = "../../stage/LOGS"

 def main():

-	usage = os.path.basename(__file__) + "--input-type=[json/pkg/who-needs] --pkg=[pkg_name] --file=<JSON_FILE_NAME> --disp=[tree/list/json]"

-	parser = OptionParser(usage)

-	parser.add_option("-i", "--input-type", dest="input_type", default=DEFAULT_INPUT_TYPE)

-	parser.add_option("-p", "--pkg", dest="pkg")

-	parser.add_option("-f", "--file", dest="json_file", default="packages_minimal.json")

-	parser.add_option("-d", "--disp", dest="display_option", default=DEFAULT_DISPLAY_OPTION) 

-	parser.add_option("-s", "--spec-dir", dest="spec_dir", default=SPEC_FILE_DIR)

-	parser.add_option("-t", "--stage-dir", dest="stage_dir", default="../../stage")

-	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 

-		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 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)

+    usage = os.path.basename(__file__) + "--input-type=[json/pkg/who-needs] --pkg=[pkg_name] --file=<JSON_FILE_NAME> --disp=[tree/list/json]"

+    parser = OptionParser(usage)

+    parser.add_option("-i", "--input-type", dest="input_type", default=DEFAULT_INPUT_TYPE)

+    parser.add_option("-p", "--pkg", dest="pkg")

+    parser.add_option("-f", "--file", dest="json_file", default="packages_minimal.json")

+    parser.add_option("-d", "--disp", dest="display_option", default=DEFAULT_DISPLAY_OPTION) 

+    parser.add_option("-s", "--spec-dir", dest="spec_dir", default=SPEC_FILE_DIR)

+    parser.add_option("-t", "--stage-dir", dest="stage_dir", default="../../stage")

+    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 

+        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 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__":

     main()

@@ -138,17 +138,17 @@ class Specutils(object):

                 for dpkg in pkg.requires:

                     dependentPackages.append(dpkg.package)

         #if (pkgName == "mono-extras"):

-	#    print "4given packages:", self.spec.packages

+    #    print "4given packages:", self.spec.packages

         #    print "4given dep packages: ", dependentPackages

         return dependentPackages

     def getBuildRequiresAllPackages(self):

-	

+    

         depedentPackages=[]

         for key in self.spec.packages.keys():

             pkg = self.spec.packages.get(key)

             #if(pkg.name == "mono"):

-            	#print "build dendent packages len 4 mono-devel:", len(pkg.buildrequires)

+                #print "build dendent packages len 4 mono-devel:", len(pkg.buildrequires)

             for dpkg in pkg.buildrequires:

                 depedentPackages.append(dpkg.package)

         depedentPackages=list(set(depedentPackages))

@@ -166,8 +166,8 @@ class Specutils(object):

         for key in self.spec.packages.keys():

             pkg = self.spec.packages.get(key)

             if pkg.name == pkgName:

-            	#if( pkgName == "mono-devel"):

-            	    #print "dendent packages len 4 mono-devel:", len(pkg.requires), pkg.requires[0].package

+                #if( pkgName == "mono-devel"):

+                    #print "dendent packages len 4 mono-devel:", len(pkg.requires), pkg.requires[0].package

                 for dpkg in pkg.requires:

                     dependentPackages.append(dpkg.package)

         return dependentPackages

@@ -177,8 +177,8 @@ class Specutils(object):

         for key in self.spec.packages.keys():

             pkg = self.spec.packages.get(key)

             if pkg.name == pkgName:

-            	#if( pkgName == "mono-devel"):

-            	    #print "build dendent packages len 4 mono-devel:", len(pkg.buildrequires), pkg.buildrequires[0].package

+                #if( pkgName == "mono-devel"):

+                    #print "build dendent packages len 4 mono-devel:", len(pkg.buildrequires), pkg.buildrequires[0].package

                 for dpkg in pkg.buildrequires:

                     dependentPackages.append(dpkg.package)

         return dependentPackages

@@ -14,8 +14,8 @@ class StringUtils(object):

         return inputstring[index+1:]

     def getSpecNameFromPackageName(self, pkgName):

-    	id = pkgName.rfind("-")

-    	if (id != -1):

-    		return pkgName[0:id];

-    	else:

-    		return pkgName;

+        id = pkgName.rfind("-")

+        if (id != -1):

+            return pkgName[0:id];

+        else:

+            return pkgName;

@@ -30,13 +30,13 @@ class ThreadPool(object):

     @staticmethod

     def addWorkerThread(workerThreadName):

         workerThread = WorkerThread.WorkerThread(

-				ThreadPool.statusEvent,

-				workerThreadName,

-				ThreadPool.mapPackageToCycle,

-				ThreadPool.listAvailableCyclicPackages,

-				ThreadPool.logger,

-				ThreadPool.listBuildOptionPackages,

-				ThreadPool.pkgBuildOptionFile)

+                ThreadPool.statusEvent,

+                workerThreadName,

+                ThreadPool.mapPackageToCycle,

+                ThreadPool.listAvailableCyclicPackages,

+                ThreadPool.logger,

+                ThreadPool.listBuildOptionPackages,

+                ThreadPool.pkgBuildOptionFile)

         ThreadPool.mapWorkerThreads[workerThreadName]=workerThread

     @staticmethod