from XmlRoutines import *
from WorkspaceRoutines import *
-verbose = False
-force = False
+class Flags:
+ """Keep track of some command line flags and operating modes."""
+ def __init__(self):
+ self.verbose = False
+ self.force = False
+ self.reinstall = False
class Database:
+ """This class encapsulates the FrameworkDatabase file for the workspace we
+ are operating on."""
+
def __init__(self, filename="Tools/Conf/FrameworkDatabase.db"):
# First try to get a lock file.
for spdfile in XmlList(self.dom, "/FrameworkDatabase/PackageList/Filename"):
filename = str(XmlElementData(spdfile))
spd = XmlParseFileSection(inWorkspace(filename), "SpdHeader")
- self.installedPackages[XmlElement(spd, "/SpdHeader/GuidValue"), XmlElement(spd, "/SpdHeader/Version")] = \
+ self.installedPackages[GetSpdGuidVersion(spd, 1)] = \
XmlElement(spd, "/SpdHeader/PackageName")
for fpdfile in XmlList(self.dom, "/FrameworkDatabase/PlatformList/Filename"):
filename = str(XmlElementData(fpdfile))
fpd = XmlParseFileSection(inWorkspace(filename), "PlatformHeader")
- self.installedPlatforms[XmlElement(fpd, "/PlatformHeader/GuidValue"), XmlElement(fpd, "/PlatformHeader/Version") ] = \
+ self.installedPlatforms[GetFpdGuidVersion(fpd, 1)] = \
XmlElement(fpd, "/PlatformHeader/PlatformName")
for farfile in XmlList(self.dom, "/FrameworkDatabase/FarList/Filename"):
return self.installedFars.has_key(farguid)
def AddPackage(self, f):
- filename = self.dom.createElement("Filename")
- filename.appendChild(self.dom.createTextNode(f))
- self.packageList.appendChild(filename)
+ """Put this package in the database"""
+ XmlAppendChildElement(self.packageList, "Filename", f)
def AddPlatform(self, f):
- filename = self.dom.createElement("Filename")
- filename.appendChild(self.dom.createTextNode(f))
- self.platformList.appendChild(filename)
+ """Put this platform in the database"""
+ XmlAppendChildElement(self.platformList, "Filename", f)
def AddFar(self, f, guid=""):
- filename = self.dom.createElement("Filename")
- filename.setAttribute("FarGuid", guid)
- filename.appendChild(self.dom.createTextNode(f))
- self.farList.appendChild(filename)
+ """Put this far in the database"""
+ XmlAppendChildElement(self.farList, "Filename", f, {"FarGuid":guid} )
def Write(self):
+ """Save the Xml tree out to the file."""
if True:
XmlSaveFile(self.dom, self.DBFile)
else:
f.write(self.dom.toprettyxml(2*" "))
f.close()
-def ExtractFile(zip, file, workspaceLocation=""):
-
- if verbose:
+def ExtractFile(zip, file, defaultDir="", workspaceLocation="", md5sum=""):
+ """Unzip a file."""
+ if flags.verbose:
print "Extracting ", file
destFile = os.path.join(inWorkspace(workspaceLocation), str(file))
mkdir(destDir)
f = open(destFile, "w")
- f.write(zip.read(file))
+ contents = zip.read(os.path.join(defaultDir,file))
+ if md5sum and (md5.md5(contents).hexdigest() != md5sum):
+ print "Error: The md5 sum does not match on file %s." % file
+ f.write(contents)
f.close()
-def GetFpdGuidVersion(Dom):
+def GetFpdGuidVersion(Dom, strip=0):
"""Get the Guid and version of the fpd from a dom object."""
- return XmlElement(Dom, "/PlatformSurfaceArea/PlatformHeader/GuidValue"), \
- XmlElement(Dom, "/PlatformSurfaceArea/PlatformHeader/Version")
+ gpath = ["PlatformSurfaceArea", "PlatformHeader", "GuidValue"]
+ vpath = ["PlatformSurfaceArea", "PlatformHeader", "Version"]
-def GetSpdGuidVersion(Dom):
+ return string.lower(XmlElement(Dom, "/".join(gpath[strip:]))), \
+ XmlElement(Dom, "/".join(vpath[strip:]))
+
+def GetSpdGuidVersion(Dom, strip=0):
"""Get the Guid and version of the spd from a dom object."""
- return XmlElement(Dom, "/PackageSurfaceArea/SpdHeader/GuidValue"), \
- XmlElement(Dom, "/PackageSurfaceArea/SpdHeader/Version")
+ gpath = ["PackageSurfaceArea", "SpdHeader", "GuidValue"]
+ vpath = ["PackageSurfaceArea", "SpdHeader", "Version"]
+
+ return string.lower(XmlElement(Dom, "/".join(gpath[strip:]))), \
+ XmlElement(Dom, "/".join(vpath[strip:]))
def InstallFar(farfile, workspaceLocation=""):
+ """Unpack the far an install it in the workspace. We need to adhere to the
+ rules of far handling."""
+
far = zipfile.ZipFile(farfile, "r")
# Use this list to make sure we get everything from the far.
# Check the packages
for farPackage in XmlList(manifest, "/FrameworkArchiveManifest/FarPackageList/FarPackage/FarFilename"):
spdfile = str(XmlElementData(farPackage))
- spd = XmlParseString(far.read(spdfile))
- packageGV = GetSpdGuidVersion(spd)
+ spd = XmlParseStringSection(far.read(spdfile), "SpdHeader")
+ packageGV = GetSpdGuidVersion(spd, 1)
if fdb.HasPackage(packageGV):
- print "Error: This package is already installed: ", spdfile
- installError = True
+ if not flags.reinstall:
+ print "Error: This package is already installed: ", spdfile
+ installError = True
# Build up a list of the package guid versions that this far is bringing in.
# This is needed to satisfy dependencies of msas that are in the other packages of
# this far.
-
farSpds.append(packageGV)
- spdDoms.append(spd)
+ spdDoms.append((spd, spdfile))
- for spd in spdDoms:
+ for spd, spdfile in spdDoms:
# Now we need to get a list of every msa in this spd and check the package dependencies.
for msafile in XmlList(spd, "/PackageSurfaceArea/MsaFiles/Filename"):
msafilePath = str(os.path.join(os.path.dirname(spdfile), XmlElementData(msafile)))
guid = package.getAttribute("PackageGuid")
version = package.getAttribute("PackageVersion")
+ # Does anyone provide this package?
if not fdb.HasPackage((guid, version)) and not (guid, version) in farSpds:
- print "The module %s depends on the package guid % version %s, which is not installed in the workspace." \
- % (msafilePath, guid, version)
+ print ("Error: The module %s depends on the package guid %s version %s, which " + \
+ "is not installed in the workspace, nor is it provided by this far.") \
+ % (msafilePath, guid, version)
installError = True
# Check the platforms
for farPlatform in XmlList(manifest, "/FrameworkArchiveManifest/FarPlatformList/FarPlatform/FarFilename"):
fpdfile = str(XmlElementData(farPlatform))
fpd = XmlParseString(far.read(fpdfile))
- if fdb.HasPlatform(GetFpdGuidVersion(fpd)):
- print "Error: This platform is already installed: ", fpdfile
- installError = True
+ if fdb.HasPlatform(GetFpdGuidVersion(fpd, 0)):
+ if not flags.reinstall:
+ print "Error: This platform is already installed: ", fpdfile
+ installError = True
+
+ # Now we need to check that all the Platforms (and modules?) that are
+ # referenced by this fpd are installed in the workspace or are in this far.
+ packagesNeeded = set()
+
+ # Go through the dependencies
+ for dependency in XmlList(fpd, "/PlatformSurfaceArea/FrameworkModules/ModuleSA") + \
+ XmlList(fpd, "/PlatformSurfaceArea/FrameworkModules/ModuleSA/Libraries/Instance"):
+ packagesNeeded.add((string.lower(dependency.getAttribute("PackageGuid")),
+ dependency.getAttribute("PackageVersion")))
+
+ # Let's see if all the packages are in the workspace
+ for guid, version in packagesNeeded:
+ # Does anyone provide this package?
+ if not fdb.HasPackage((guid, version)) and not (guid, version) in farSpds:
+ print ("Error: The fpd %s depends on the package guid %s version %s, which " + \
+ "is not installed in the workspace, nor is it provided by this far.") \
+ % (fpdfile, guid, version)
+ installError = True
# Check the fars
- thisFarGuid = XmlElement(manifest, "/FrameworkArchiveManifest/FarHeader/GuidValue")
+ thisFarGuid = string.lower(XmlElement(manifest, "/FrameworkArchiveManifest/FarHeader/GuidValue"))
if fdb.HasFar(thisFarGuid):
- print "Error: There is a far with this guid already installed."
- installError = True
+ if not flags.reinstall:
+ print "Error: There is a far with this guid already installed."
+ installError = True
# We can not do the install
if installError:
- if force:
- print "Ignoring previous errors as you requested."
+ if flags.force:
+ print "Warning: Ignoring previous errors as you requested."
else:
return False
for farPackage in XmlList(manifest, "/FrameworkArchiveManifest/FarPackageList/FarPackage"):
filename = XmlElement(farPackage, "FarPackage/FarFilename")
- fdb.AddPackage(filename)
+ if not flags.reinstall:
+ fdb.AddPackage(filename)
ExtractFile(far, filename, workspaceLocation)
zipContents.remove(filename)
+ DefaultPath = XmlElement(farPackage, "FarPackage/DefaultPath")
+
for content in XmlList(farPackage, "FarPackage/Contents/FarFilename"):
filename = XmlElementData(content)
- ExtractFile(far, filename, workspaceLocation)
- zipContents.remove(filename)
+ ExtractFile(far, filename, DefaultPath, workspaceLocation, md5sum=content.getAttribute("Md5Sum"))
+ zipContents.remove(os.path.join(DefaultPath, filename))
# Install the platforms
for farPlatform in XmlList(manifest, "/FrameworkArchiveManifest/FarPlatformList/FarPlatform"):
filename = XmlElement(farPlatform, "FarPlatform/FarFilename")
- fdb.AddPlatform(filename)
- ExtractFile(far, filename, workspaceLocation)
+ if not flags.reinstall:
+ fdb.AddPlatform(filename)
+ ExtractFile(far, filename, "", workspaceLocation)
zipContents.remove(filename)
# Install the Contents
for content in XmlList(manifest, "/FrameworkArchiveManifest/Contents/FarFilename"):
filename = XmlElementData(content)
- ExtractFile(far, filename, workspaceLocation)
+ ExtractFile(far, filename, "", workspaceLocation)
zipContents.remove(filename)
# What if there are more files in the far?
if not zipContents == []:
- print "There are still files in the far:", zipContents
+ print "Warning: There are files in the far that were not expected: ", zipContents
- fdb.AddFar(farfile, thisFarGuid)
+ if not flags.reinstall:
+ fdb.AddFar(farfile, thisFarGuid)
# If everything has gone well, we can put the manifest file in a safe place...
farDir = inWorkspace("Tools/Conf/InstalledFars/")
f.close()
# Write out the new database
- fdb.Write()
+ if not flags.reinstall:
+ fdb.Write()
far.close()
# into another script.
if __name__ == '__main__':
+ flags = Flags()
+
# Process the command line args.
- optlist, args = getopt.getopt(sys.argv[1:], '?hvf', ['help', 'verbose', 'force'])
+ optlist, args = getopt.getopt(sys.argv[1:], '?hvf', ['help', 'verbose', 'force', 'reinstall'])
# First pass through the options list.
for o, a in optlist:
- if o in ["-h", "--help"]:
+ if o in ["-h", "-?", "--help"]:
print """
-Install a far (Framework Archive) into the current workspace.
+%s: Install a far (Framework Archive) into the current workspace.
""" % os.path.basename(sys.argv[0])
sys.exit()
optlist.remove((o,a))
if o in ["-v", "--verbose"]:
- verbose = True
+ flags.verbose = True
if o in ["-f", "--force"]:
- force = True
+ flags.force = True
+ if o in ["--reinstall"]:
+ flags.reinstall = True
for f in args:
InstallFar(f)
"""Create a dom tree for the Far Header. It will use information from the
template file passed on the command line, if present."""
-
- header = doc.createElement("FarHeader")
- name = doc.createElement("FarName")
- name.appendChild(doc.createTextNode(far.FarName))
- header.appendChild(name)
- guidVal = doc.createElement("GuidValue")
- guidVal.appendChild(doc.createTextNode(genguid()))
- header.appendChild(guidVal)
- ver = doc.createElement("Version")
- ver.appendChild(doc.createTextNode(far.Version))
- header.appendChild(ver)
- abstract = doc.createElement("Abstract")
- abstract.appendChild(doc.createTextNode(far.Abstract))
- header.appendChild(abstract)
- desc = doc.createElement("Description")
- desc.appendChild(doc.createTextNode(far.Description))
- header.appendChild(desc)
- copy = doc.createElement("Copyright")
- copy.appendChild(doc.createTextNode(far.Copyright))
- header.appendChild(copy)
- lic = doc.createElement("License")
- lic.appendChild(doc.createTextNode(far.License))
- header.appendChild(lic)
- spec = doc.createElement("Specification")
- spec.appendChild(doc.createTextNode("FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052"))
- header.appendChild(spec)
+
+ header = XmlAppendChildElement(doc.documentElement, "FarHeader")
+
+ XmlAppendChildElement(header, "FarName", far.FarName)
+ XmlAppendChildElement(header, "GuidValue", genguid())
+ XmlAppendChildElement(header, "Version", far.Version)
+ XmlAppendChildElement(header, "Abstract", far.Abstract)
+ XmlAppendChildElement(header, "Description", far.Description)
+ XmlAppendChildElement(header, "Copyright", far.Copyright)
+ XmlAppendChildElement(header, "License", far.License)
+ XmlAppendChildElement(header, "Specification", "FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052")
return header
top_element.appendChild(makeFarHeader(man))
- packList = man.createElement("FarPackageList")
- top_element.appendChild(packList)
-
- platList = man.createElement("FarPlatformList")
- top_element.appendChild(platList)
-
- contents = man.createElement("Contents")
- top_element.appendChild(contents)
-
- exts = man.createElement("UserExtensions")
- top_element.appendChild(exts)
+ packList = XmlAppendChildElement(top_element, "FarPackageList")
+ platList = XmlAppendChildElement(top_element, "FarPlatformList")
+ contents = XmlAppendChildElement(top_element, "Contents")
+ XmlAppendChildElement(top_element, "UserExtensions")
zip = zipfile.ZipFile(farname, "w")
for infile in set(files):
(spdGuid, spdVersion) = getSpdGuidVersion(infile)
- package = man.createElement("FarPackage")
- packList.appendChild(package)
-
- spdfilename = farFileNode(man, inWorkspace(infile))
+ package = XmlAppendChildElement(packList, "FarPackage")
+ XmlAppendChildElement(package, "FarFilename", lean(infile), {"Md5Sum": Md5(inWorkspace(infile))})
zip.write(inWorkspace(infile), infile)
- spdfilename.appendChild(man.createTextNode(lean(infile)))
- package.appendChild(spdfilename)
-
- guidValue = man.createElement("GuidValue")
- guidValue.appendChild(man.createTextNode(spdGuid))
- package.appendChild(guidValue)
-
- version = man.createElement("Version")
- version.appendChild(man.createTextNode(spdVersion))
- package.appendChild(version)
-
- defaultPath = man.createElement("DefaultPath")
- defaultPath.appendChild(man.createTextNode(spdDir))
- package.appendChild(defaultPath)
-
- farPlatformList = man.createElement("FarPlatformList")
- package.appendChild(farPlatformList)
-
- packContents = man.createElement("Contents")
- package.appendChild(packContents)
-
- ue = man.createElement("UserExtensions")
- package.appendChild(ue)
+ XmlAppendChildElement(package, "GuidValue", spdGuid)
+ XmlAppendChildElement(package, "Version", spdVersion)
+ XmlAppendChildElement(package, "DefaultPath", spdDir)
+ XmlAppendChildElement(package, "FarPlatformList")
+ packContents = XmlAppendChildElement(package, "Contents")
+ XmlAppendChildElement(package, "UserExtensions")
for spdfile in filelist:
- content = farFileNode(man, inWorkspace(os.path.join(spdDir, spdfile)))
+ XmlAppendChildElement(packContents, "FarFilename", lean(spdfile), {"Md5Sum": Md5(inWorkspace(os.path.join(spdDir, spdfile)))})
zip.write(inWorkspace(os.path.join(spdDir, spdfile)), os.path.join(spdDir,spdfile))
- content.appendChild(man.createTextNode(lean(spdfile)))
- packContents.appendChild(content)
elif extension == ".fpd":
- platform = man.createElement("FarPlatform")
- platList.appendChild(platform)
-
- fpdfilename = farFileNode(man, inWorkspace(infile))
+ platform = XmlAppendChildElement(platList, "FarPlatform")
+ XmlAppendChildElement(platform, "FarFilename", lean(infile), {"Md5Sum": Md5(inWorkspace(infile))})
zip.write(inWorkspace(infile), infile)
- platform.appendChild(fpdfilename)
- fpdfilename.appendChild(man.createTextNode(lean(infile)))
else:
- content = farFileNode(man, inWorkspace(infile))
+ XmlAppendChildElement(contents, "FarFilename", lean(infile), {"Md5Sum": Md5(inWorkspace(infile))})
zip.write(inWorkspace(infile), infile)
- content.appendChild(man.createTextNode(lean(infile)))
- contents.appendChild(content)
- zip.writestr("FrameworkArchiveManifest.xml", man.toprettyxml(2*" "))
+ zip.writestr("FrameworkArchiveManifest.xml", man.toxml('UTF-8'))
zip.close()
return
-def farFileNode(doc, filename):
-
- """This is a function that returns a dom tree for a given file that is
- included in the far. An md5sum is calculated for that file."""
-
- content = doc.createElement("FarFilename")
- try:
- f=open(filename, "rb")
- content.setAttribute("Md5sum", md5.md5(f.read()).hexdigest())
- f.close()
- except IOError:
- print "Error: Unable to open file: %s" % filename
- sys.exit()
-
- return content
-
# This acts like the main() function for the script, unless it is 'import'ed
# into another script.
if __name__ == '__main__':
# pp = pprint.PrettyPrinter(indent=2)
# Process the command line args.
- optlist, args = getopt.getopt(sys.argv[1:], 'hf:t:', [ 'template=', 'far=', 'help'])
+ optlist, args = getopt.getopt(sys.argv[1:], 'ho:t:v', [ 'template=', 'output=', 'far=', 'help', 'debug', 'verbose', 'version'])
# First pass through the options list.
for o, a in optlist:
# Second pass through the options list. These can override the first pass.
for o, a in optlist:
print o, a
- if o in ["-f", "--far"]:
+ if o in ["-o", "--far", "--output"]:
far.FileName = a
# Let's err on the side of caution and not let people blow away data
projects / mirror_edk2.git / commitdiff