deleted file mode 100644

@@ -1,14 +0,0 @@

-import commands

-

-class RepoQueryDependency(object):

-    def __init__(self, repoFile):

-        self.repo_file = repoFile

-    def getRequiresList(self,pkg):

-        cmd = "repoquery -c "+self.repo_file+" -R -q "+pkg+" | xargs repoquery -c "+self.repo_file+" --whatprovides -q | sed 's/-[0-9]/ /g' | cut -f 1 -d ' ' | sort | uniq "

-        status,output = commands.getstatusoutput(cmd)

-        if status == 0:

-            outList = output.split('\n')

-            if "" in outList: outList.remove("")

-            if "Options:" in outList: outList.remove("Options:")

-            if "Usage:" in outList: outList.remove("Usage:")

-            return outList

deleted file mode 100644

@@ -1,280 +0,0 @@

-from SpecUtils import Specutils

-from StringUtils import StringUtils

-import operator

-import os

-import collections

-import Queue

-import json

-

-class SerializableSpecObject(object):

-    def __init__(self):

-        self.listPackages=[]

-        self.name=""

-        self.version=""

-        self.release=""

-        self.buildRequirePackages=[]

-        self.installRequiresAllPackages=[]

-        self.installRequiresPackages={}

-        self.specFile=""

-        self.listSources=[]

-        self.listPatches=[]

-        self.securityHardening=""

-

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

-            if specName is None:

-                print specPkg + " is missing"

-            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 findTotalWhoNeedsToBuild(self, depQue, whoBuildDeps, whoBuildDepSet, displayOption):

-        while not depQue.empty():

-            specPkg = depQue.get()

-            specName = self.getSpecName(specPkg)

-            spec=Specutils(self.getSpecFile(specPkg))

-            RPMName=spec.getRPMName(specPkg)

-            debuginfoRPMName=spec.getDebuginfoRPMName(specPkg)

-            whoBuildDepSet.add(RPMName)

-            whoBuildDepSet.add(debuginfoRPMName)

-            if specName is None:

-                print specPkg + " is missing"

-            if not whoBuildDeps.has_key(specPkg):

-                continue

-            for depPkg in whoBuildDeps[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=[]

-        whoBuildDepSet= set()

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

-        whoBuildDeps = {}

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

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

-                    whoNeedsList.append(specPkg)

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

-                    for bdrq in specObj.buildRequirePackages:

-                        if (whoBuildDeps.has_key(bdrq)):

-                            whoBuildDeps[bdrq].add(specPkg)

-                        else:

-                            whoBuildDeps[bdrq] = set()

-                            whoBuildDeps[bdrq].add(specPkg)

-                    if(inputValue == specPkg):

-                        packageFound = True

-                        for depPkg in specObj.listPackages:

-                            depQue.put(depPkg)

-

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

-

-        #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 the modified package will affect at build time

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

-            if (packageFound == True):

-                self.findTotalWhoNeedsToBuild(depQue, whoBuildDeps, whoBuildDepSet, displayOption)

-                print whoBuildDepSet

-            else:

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

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

-        return sortedList

-

-    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 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 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 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 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 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 getSpecDetails(self, name):

-        print self.mapSerializableSpecObjects[name].installRequiresAllPackages

-

deleted file mode 100755

@@ -1,57 +0,0 @@

-#! /usr/bin/python2

-#

-#    Copyright (C) 2015 vmware inc.

-#

-#    Author: Harish Udaiya Kumar <hudaiyakumar@vmware.com>

-from SpecUtils import Specutils

-from SpecData import SerializableSpecObject

-from SpecData import SerializedSpecObjects

-import sys

-import os

-from optparse import OptionParser

-from jsonwrapper import JsonWrapper

-

-DEFAULT_INPUT_TYPE = "pkg"

-DEFAULT_DISPLAY_OPTION = "tree"

-SPEC_FILE_DIR = "../../SPECS"

-LOG_FILE_DIR = "../../stage/LOGS"

-

-

-def main():

-    usage = os.path.basename(__file__) + "--input-type=[json/pkg/who-needs/who-needs-build] --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)

-

-    # To display/print package dependencies on console

-    if(options.input_type == "pkg" or options.input_type == "who-needs" or options.input_type == "who-needs-build"):

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

deleted file mode 100644

@@ -1,322 +0,0 @@

-import re

-from StringUtils import StringUtils

-from SpecStructures import *

-

-class SpecParser(object):

-    def __init__(self):

-        self.cleanMacro=rpmMacro().setName("clean")

-        self.prepMacro=rpmMacro().setName("prep")

-        self.buildMacro=rpmMacro().setName("build")

-        self.installMacro=rpmMacro().setName("install")

-        self.changelogMacro=rpmMacro().setName("changelog")

-        self.checkMacro=rpmMacro().setName("check")

-        self.packages={}

-        self.specAdditionalContent=""

-        self.globalSecurityHardening=""

-        

-    

-    def readPkgNameFromPackageMacro(self,data,basePkgName=None):

-        data=" ".join(data.split())

-        pkgHeaderName=data.split(" ")

-        lenpkgHeaderName = len(pkgHeaderName)

-        

-        if (lenpkgHeaderName >= 3 and pkgHeaderName[1] != "-n"):

-            lenpkgHeaderName = 1

-        if (lenpkgHeaderName == 2 or lenpkgHeaderName == 1 ) and basePkgName is None :

-            print "Invalid basePkgName"

-            return False,None

-        if lenpkgHeaderName == 3 :

-            return True,pkgHeaderName[2]

-        if lenpkgHeaderName == 2 :

-            return True,basePkgName + "-"+pkgHeaderName[1]

-        if lenpkgHeaderName == 1:

-            return True, basePkgName

-    

-    def parseSpecFile(self,specfile):

-        self.createDefaultPackage()

-        currentPkg="default"

-        specFile = open(specfile)

-        lines = specFile.readlines()

-        totalLines=len(lines)

-        i=0

-        while i < totalLines:

-            line = lines[i].strip()

-            if self.isSpecMacro(line):

-                macro,i=self.readMacroFromFile(i, lines)

-                self.updateMacro(macro)

-            elif self.isPackageMacro(line):

-                defaultpkg = self.packages.get('default')

-                returnVal,packageName=self.readPkgNameFromPackageMacro(line, defaultpkg.name)

-                packageName=defaultpkg.decodeContents(packageName)

-                if not returnVal:

-                    return False

-                if re.search('^'+'%package',line) :

-                    pkg = Package(defaultpkg)

-                    pkg.name=packageName

-                    currentPkg=packageName

-                    self.packages[pkg.name]=pkg

-                else:

-                    if defaultpkg.name == packageName :

-                        packageName = 'default'

-                    if not self.packages.has_key(packageName):

-                        return False

-                    macro,i=self.readMacroFromFile(i, lines)

-                    self.packages[packageName].updatePackageMacro(macro)

-            elif self.isPackageHeaders(line):

-                self.readPackageHeaders(line, self.packages[currentPkg])

-            elif self.isGlobalSecurityHardening(line):

-                self.readSecurityHardening(line)

-            else:

-                self.specAdditionalContent+=line+"\n"

-            i=i+1

-        specFile.close()

-    

-    def createDefaultPackage(self):

-        pkg = Package()

-        self.packages["default"]=pkg

-    

-    def readMacroFromFile(self,currentPos,lines):

-        macro = rpmMacro()

-        line = lines[currentPos]

-        macro.position = currentPos

-        macro.endposition=currentPos

-        endPos=len(lines)

-        line = " ".join(line.split())

-        flagindex = line.find(" ")

-        if flagindex != -1:

-            macro.macroFlag=line[flagindex+1:]

-            macro.macroName=line[:flagindex]

-        else:

-            macro.macroName=line

-

-        if currentPos+1 < len(lines) and self.isMacro(lines[currentPos+1]):

-            return macro,currentPos

-            

-        for j in range(currentPos+1,endPos):

-            content = lines[j]

-            if j+1 < endPos and self.isMacro(lines[j+1]):

-                return macro,j

-            macro.content += content +'\n'

-            macro.endposition=j

-        return macro,endPos

-        

-

-    def updateMacro(self,macro):

-        if macro.macroName == "%clean":

-            self.cleanMacro=macro

-            return True

-        if macro.macroName == "%prep":

-            self.prepMacro=macro

-            return True

-        if macro.macroName == "%build":

-            self.buildMacro=macro

-            return True

-        if macro.macroName == "%install":

-            self.installMacro=macro

-            return True

-        if macro.macroName == "%changelog":

-            self.changelogMacro=macro

-            return True

-        if macro.macroName == "%check":

-            self.checkMacro=macro

-            return True

-        return False

-            

-    def isMacro(self,line):

-        return self.isPackageMacro(line) or self.isSpecMacro(line)

-    

-    def isSpecMacro(self,line):

-        if re.search('^'+'%clean',line) :

-            return True

-        elif re.search('^'+'%prep',line) :

-            return True            

-        elif re.search('^'+'%build',line) :

-            return True

-        elif re.search('^'+'%install',line) :

-            return True

-        elif re.search('^'+'%changelog',line) :

-            return True

-        elif re.search('^'+'%check',line) :

-            return True

-        return False

-    

-    def isPackageMacro(self,line):

-        line=line.strip()

-# What is the point of this function?

-# Why does it track post/postun sections?

-#        if re.search('^'+'%post',line) :

-#            return True

-#        elif re.search('^'+'%postun',line) :

-#            return True

-        if re.search('^'+'%files',line) :

-            return True

-        elif re.search('^'+'%description',line) :

-            return True

-        elif re.search('^'+'%package',line) :

-            return True

-        return False

-    

-    def isPackageHeaders(self,line):

-        if re.search('^'+'summary:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'name:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'group:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'license:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'version:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'release:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'distribution:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'requires:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'provides:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'obsoletes:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'conflicts:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'url:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'source[0-9]*:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'patch[0-9]*:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'buildrequires:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'buildprovides:',line,flags=re.IGNORECASE) :

-            return True

-        elif re.search('^'+'buildarch:',line,flags=re.IGNORECASE) :

-            return True

-        return False

-

-    def isGlobalSecurityHardening(self,line):

-        if re.search('^%global *security_hardening',line,flags=re.IGNORECASE) :

-            return True

-        return False

-

-    def readHeader(self,line):

-        headerSplitIndex=line.find(":")

-        if(headerSplitIndex+1 == len(line) ):

-            print line

-            print "Error:Invalid header"

-            return False, None,None

-        headerName=line[0:headerSplitIndex].lower()

-        headerContent=line[headerSplitIndex+1:].strip()

-        return True,headerName,headerContent

-

-

-    def readDependentPackageData(self,line):

-        strUtils = StringUtils()

-        listPackages=line.split(",")

-        listdependentpkgs=[]

-        for line in listPackages:

-            line=strUtils.getStringInBrackets(line)

-            listContents=line.split()

-            totalContents = len(listContents)

-            i=0

-            while i < totalContents:

-                dpkg = dependentPackageData()

-                compare=None

-                if listContents[i].startswith("/"):

-                    i=i+1

-                    continue

-                if i+2 < len(listContents):

-                    if listContents[i+1] == ">=":

-                        compare="gte"

-                    elif listContents[i+1] == "<=":

-                        compare="lte"

-                    elif listContents[i+1] == "==":

-                        compare="eq"

-                    elif listContents[i+1] == "<":

-                        compare="lt"

-                    elif listContents[i+1] == ">":

-                        compare="gt"

-                    elif listContents[i+1] == "=":

-                        compare="eq"

-                    

-                if compare is not None:

-                    dpkg.package=listContents[i]

-                    dpkg.compare=compare

-                    dpkg.version=listContents[i+2]

-                    i=i+3

-                else:

-                    dpkg.package=listContents[i]

-                    i=i+1

-                listdependentpkgs.append(dpkg)

-        return listdependentpkgs

-

-    def readPackageHeaders(self,line,pkg):

-        returnVal,headerName,headerContent=self.readHeader(line)

-        if not returnVal:

-            return False

-

-        headerContent=pkg.decodeContents(headerContent)

-        if headerName == 'summary':

-            pkg.summary=headerContent

-            return True

-        if headerName == 'name':

-            pkg.name=headerContent

-            return True

-        if headerName == 'group':

-            pkg.group=headerContent

-            return True

-        if headerName == 'license':

-            pkg.license=headerContent

-            return True

-        if headerName == 'version':

-            pkg.version=headerContent

-            return True

-        if headerName == 'buildarch':

-            pkg.buildarch=headerContent

-            return True

-        if headerName == 'release':

-            pkg.release=headerContent

-            return True

-        if headerName == 'distribution':

-            pkg.distribution=headerContent

-            return True

-        if headerName == 'url':

-            pkg.URL=headerContent

-            return True

-        if headerName.find('source') != -1:

-            pkg.sources.append(headerContent)

-            return True

-        if headerName.find('patch') != -1:

-            pkg.patches.append(headerContent)

-            return True

-        if headerName == 'requires' or headerName == 'provides' or headerName == 'obsoletes' or headerName == 'conflicts' or headerName == 'buildrequires' or headerName == 'buildprovides':

-            dpkg=self.readDependentPackageData(headerContent)

-            if dpkg is None:

-                return False

-            if headerName == 'requires':

-                pkg.requires.extend(dpkg)

-            if headerName == 'provides':

-                pkg.provides.extend(dpkg)

-            if headerName == 'obsoletes':

-                pkg.obsoletes.extend(dpkg)

-            if headerName == 'conflicts':

-                pkg.conflicts.extend(dpkg)

-            if headerName == 'buildrequires':

-                pkg.buildrequires.extend(dpkg)

-            if headerName == 'buildprovides':

-                pkg.buildprovides.extend(dpkg)

-                    

-            return True

-        return False

-

-    def readSecurityHardening(self,line):

-        data = line.lower().strip();

-        words=data.split(" ")

-        nrWords = len(words)

-        if (nrWords != 3):

-            print "Error: Unable to parse line: "+line

-            return False

-        if (words[2] != "none" and words[2] != "nonow") :

-            print "Error: Invalid security_hardening value: " + words[2]

-            return False

-        self.globalSecurityHardening = words[2]

-        return True;

deleted file mode 100644

@@ -1,105 +0,0 @@

-class rpmMacro(object):

-

-    def __init__(self):

-        self.macroName=""

-        self.macroFlag=""

-        self.content=""

-        self.position=-1

-        self.endposition=-1

-

-    def setName(self,name):

-        self.macroName=name

-        

-    def displayMacro(self):

-        print "Macro:\n", self.macroName, " ",self.macroFlag," ",self.position," ",self.endposition

-        print self.content

-    

-class dependentPackageData(object):

-

-    def __init__(self):

-        self.package=""

-        self.version=""

-        self.compare=""

-        

-class Package(object):

-    def __init__(self, basePkg=None):

-        self.summary=""

-        self.name=""

-        self.group=""

-        self.license=""

-        self.version=""

-        self.release=""

-        self.buildarch="x86_64"

-        self.distribution=""

-        self.basePkgName=""

-        

-        self.sources=[]

-        self.patches=[]

-        self.buildrequires=[]

-        self.buildprovides=[]

-        

-        

-        self.requires=[]

-        self.provides=[]

-        self.obsoletes=[]

-        self.conflicts=[]

-        

-        self.descriptionMacro= None

-        self.postMacro=None

-        self.postunMacro=None

-        self.filesMacro=None

-        self.packageMacro=None

-        

-        if basePkg is not None:

-            self.basePkgName=basePkg.name

-            self.group=basePkg.group

-            self.license=basePkg.license

-            self.version=basePkg.version

-            self.buildarch=basePkg.buildarch

-            self.release=basePkg.release

-            self.distribution=basePkg.distribution

-        

-    def decodeContents(self,content):

-        if content.find("%{name}") != -1:

-            if self.basePkgName == "":

-                content = content.replace('%{name}',self.name)

-            else:

-                content = content.replace('%{name}',self.basePkgName)

-        

-        if content.find("%{release}") != -1:

-            content = content.replace('%{release}',self.release)

-        

-        if content.find("%{version}") != -1:

-            content = content.replace('%{version}',self.version)

-        

-        if content.find("%{?dist}") != -1:

-            content = content.replace('%{?dist}',self.distribution)

-

-        if content.find("%{dist}") != -1:

-            content = content.replace('%{dist}',self.distribution)

-        

-        # TODO: A temporary hack here. The reason is this macro

-        # can't be subsitute properly.

-        # At this file level, we won't be able to obtain any other

-        # packages' information. This macro requires the information

-        # of package linux. Besides, there is a huge diversion

-        # between package-builder and SpecDeps.

-        if content.find("%{?kernelsubrelease}") != -1:

-            content = content.replace('%{?kernelsubrelease}',"")

-

-        return content

-    

-    def updatePackageMacro(self,macro):

-        if macro.macroName == "%post":

-            self.postMacro=macro

-            return True

-        if macro.macroName == "%postun":

-            self.postunMacro=macro

-            return True

-        if macro.macroName == "%files":

-            self.filesMacro=macro

-            return True

-        if macro.macroName == "%description":

-            self.descriptionMacro = macro

-            return True

-        return False

deleted file mode 100644

@@ -1,243 +0,0 @@

-from SpecParser import SpecParser

-from StringUtils import StringUtils

-import os

-

-class Specutils(object):

-    

-    def __init__(self,specfile):

-        self.specfile=""

-        self.spec = SpecParser()

-        if self.isSpecFile(specfile):

-            self.specfile=specfile

-            self.spec.parseSpecFile(self.specfile)

-    

-    def isSpecFile(self,specfile):

-        if os.path.isfile(specfile) and specfile[-5:] == ".spec":

-            return True

-        return False

-    

-    def getSourceNames(self):

-        sourceNames=[]

-        strUtils = StringUtils()

-        pkg = self.spec.packages.get('default')

-        if pkg is None:

-            return None

-        for source in pkg.sources:

-            sourceName=strUtils.getFileNameFromURL(source)

-            sourceNames.append(sourceName)

-        return sourceNames

-    

-    def getSourceURLs(self):

-        sourceNames=[]

-        strUtils = StringUtils()

-        pkg = self.spec.packages.get('default')

-        if pkg is None:

-            return None

-        for source in pkg.sources:

-            sourceNames.append(source)

-        return sourceNames

-

-    def getPatchNames(self):

-        patchNames=[]

-        strUtils = StringUtils()

-        pkg = self.spec.packages.get('default')

-        if pkg is None:

-            return None

-        for patch in pkg.patches:

-            patchName=strUtils.getFileNameFromURL(patch)

-            patchNames.append(patchName)

-        return patchNames

-    

-    def getPackageNames(self):

-        packageNames=[]

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

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

-            packageNames.append(pkg.name)

-        return packageNames

-    

-    def getRPMNames(self):

-        rpmNames=[]

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

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

-            rpmName=pkg.name+"-"+pkg.version+"-"+pkg.release

-            rpmNames.append(rpmName)

-        return rpmNames

-

-    def getRPMName(self, pkgName):

-        rpmName=None

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

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

-            if pkg.name == pkgName:

-                rpmName=pkg.name+"-"+pkg.version+"-"+pkg.release

-                break

-        return rpmName

-

-    def getDebuginfoRPMName(self, pkgName):