From 4234283c3acb8c35014acc1546621fbc2621b095 Mon Sep 17 00:00:00 2001 From: lgao4 Date: Fri, 26 Aug 2011 07:46:26 +0000 Subject: Sync BaseTools Branch (version r2271) to EDKII main trunk. BaseTool Branch: https://edk2-buildtools.svn.sourceforge.net/svnroot/edk2-buildtools/branches/Releases/BaseTools_r2100 Signed-off-by: lgao4 Reviewed-by: hchen30 git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@12214 6f19259b-4bc3-4df7-8a09-765794883524 --- .../Source/Python/UPT/Core/DependencyRules.py | 293 +++++++ .../Python/UPT/Core/DistributionPackageClass.py | 228 ++++++ BaseTools/Source/Python/UPT/Core/IpiDb.py | 867 +++++++++++++++++++++ BaseTools/Source/Python/UPT/Core/PackageFile.py | 249 ++++++ BaseTools/Source/Python/UPT/Core/__init__.py | 20 + 5 files changed, 1657 insertions(+) create mode 100644 BaseTools/Source/Python/UPT/Core/DependencyRules.py create mode 100644 BaseTools/Source/Python/UPT/Core/DistributionPackageClass.py create mode 100644 BaseTools/Source/Python/UPT/Core/IpiDb.py create mode 100644 BaseTools/Source/Python/UPT/Core/PackageFile.py create mode 100644 BaseTools/Source/Python/UPT/Core/__init__.py (limited to 'BaseTools/Source/Python/UPT/Core') diff --git a/BaseTools/Source/Python/UPT/Core/DependencyRules.py b/BaseTools/Source/Python/UPT/Core/DependencyRules.py new file mode 100644 index 0000000000..ac656bb02a --- /dev/null +++ b/BaseTools/Source/Python/UPT/Core/DependencyRules.py @@ -0,0 +1,293 @@ +## @file +# This file is for installed package information database operations +# +# Copyright (c) 2011, Intel Corporation. All rights reserved.
+# +# This program and the accompanying materials are licensed and made available +# under the terms and conditions of the BSD License which accompanies this +# distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +''' +Dependency +''' + +## +# Import Modules +# +from os import getenv +from os import environ +from os.path import dirname + +import Logger.Log as Logger +from Logger import StringTable as ST +from Library.Parsing import GetWorkspacePackage +from Library.Parsing import GetWorkspaceModule +from PomAdapter.InfPomAlignment import InfPomAlignment +from Logger.ToolError import FatalError +from Logger.ToolError import EDK1_INF_ERROR +from Logger.ToolError import UNKNOWN_ERROR +(DEPEX_CHECK_SUCCESS, DEPEX_CHECK_MODULE_NOT_FOUND, \ +DEPEX_CHECK_PACKAGE_NOT_FOUND, DEPEX_CHECK_DP_NOT_FOUND) = (0, 1, 2, 3) + + +## IpiDb +# +# This class represents the installed package information database +# Add/Remove/Get installed distribution package information here. +# +# +# @param object: Inherited from object class +# +class DependencyRules(object): + def __init__(self, Datab): + self.IpiDb = Datab + self.WsPkgList = GetWorkspacePackage() + self.WsModuleList = GetWorkspaceModule() + + ## Check whether a module exists in current workspace. + # + # @param Guid: Guid of a module + # @param Version: Version of a module + # + def CheckModuleExists(self, Guid, Version, ReturnCode=DEPEX_CHECK_SUCCESS): + if ReturnCode: + pass + Logger.Verbose(ST.MSG_CHECK_MODULE_EXIST) + ModuleList = self.IpiDb.GetModInPackage(Guid, Version) + ModuleList.extend(self.IpiDb.GetStandaloneModule(Guid, Version)) + Logger.Verbose(ST.MSG_CHECK_MODULE_EXIST_FINISH) + if len(ModuleList) > 0: + return True + else: + return False + + ## Check whether a module depex satisfied by current workspace or dist. + # + # @param ModuleObj: A module object + # @param DpObj: A depex object + # + def CheckModuleDepexSatisfied(self, ModuleObj, DpObj=None, \ + ReturnCode=DEPEX_CHECK_SUCCESS): + if ReturnCode: + pass + Logger.Verbose(ST.MSG_CHECK_MODULE_DEPEX_START) + Result = True + Dep = None + if ModuleObj.GetPackageDependencyList(): + Dep = ModuleObj.GetPackageDependencyList()[0] + for Dep in ModuleObj.GetPackageDependencyList(): + # + # first check whether the dependency satisfied by current workspace + # + Exist = self.CheckPackageExists(Dep.GetGuid(), Dep.GetVersion()) + # + # check whether satisfied by current distribution + # + if not Exist: + if DpObj == None: + Result = False + break + for GuidVerPair in DpObj.PackageSurfaceArea.keys(): + if Dep.GetGuid() == GuidVerPair[0]: + if Dep.GetVersion() == None or \ + len(Dep.GetVersion()) == 0: + Result = True + break + if Dep.GetVersion() == GuidVerPair[1]: + Result = True + break + else: + Result = False + break + + if not Result: + Logger.Error("CheckModuleDepex", UNKNOWN_ERROR, \ + ST.ERR_DEPENDENCY_NOT_MATCH % (ModuleObj.GetName(), \ + Dep.GetPackageFilePath(), \ + Dep.GetGuid(), \ + Dep.GetVersion())) + return Result + + ## Check whether a package exists in current workspace. + # + # @param Guid: Guid of a package + # @param Version: Version of a package + # + def CheckPackageExists(self, Guid, Version): + Logger.Verbose(ST.MSG_CHECK_PACKAGE_START) + for (PkgName, PkgGuid, PkgVer, PkgPath) in self.WsPkgList: + if PkgName or PkgPath: + pass + if (PkgGuid == Guid): + # + # if version is not empty and not equal, then not match + # + if Version and (PkgVer != Version): + return False + else: + return True + else: + return False + + Logger.Verbose(ST.MSG_CHECK_PACKAGE_FINISH) + + ## Check whether a package depex satisfied by current workspace. + # + # @param PkgObj: A package object + # @param DpObj: A package depex object + # + def CheckPackageDepexSatisfied(self, PkgObj, DpObj=None, \ + ReturnCode=DEPEX_CHECK_SUCCESS): + + ModuleDict = PkgObj.GetModuleDict() + for ModKey in ModuleDict.keys(): + ModObj = ModuleDict[ModKey] + if self.CheckModuleDepexSatisfied(ModObj, DpObj, ReturnCode): + continue + else: + return False + return True + + ## Check whether a DP exists in current workspace. + # + # @param Guid: Guid of a module + # @param Version: Version of a module + # + def CheckDpExists(self, Guid, Version, ReturnCode=DEPEX_CHECK_SUCCESS): + if ReturnCode: + pass + Logger.Verbose(ST.MSG_CHECK_DP_START) + DpList = self.IpiDb.GetDp(Guid, Version) + if len(DpList) > 0: + return True + else: + return False + + Logger.Verbose(ST.MSG_CHECK_DP_FINISH) + + ## Check whether a DP depex satisfied by current workspace. + # + # @param DpObj: Depex object + # @param ReturnCode: ReturnCode + # + def CheckDpDepexSatisfied(self, DpObj, ReturnCode=DEPEX_CHECK_SUCCESS): + + for PkgKey in DpObj.PackageSurfaceArea.keys(): + PkgObj = DpObj.PackageSurfaceArea[PkgKey] + if self.CheckPackageDepexSatisfied(PkgObj, DpObj, ReturnCode): + continue + else: + return False + + for ModKey in DpObj.ModuleSurfaceArea.keys(): + ModObj = DpObj.ModuleSurfaceArea[ModKey] + if self.CheckModuleDepexSatisfied(ModObj, DpObj, ReturnCode): + continue + else: + return False + + return True + + ## Check whether a DP depex satisfied by current workspace. Return False + # if Can not remove (there is dependency), True else + # + # @param DpGuid: File's guid + # @param DpVersion: File's version + # @param ReturnCode: ReturnCode + # + def CheckDpDepexForRemove(self, DpGuid, DpVersion, \ + ReturnCode=DEPEX_CHECK_SUCCESS): + if ReturnCode: + pass + Removable = True + DependModuleList = [] + WsModuleList = self.WsModuleList + # + # remove modules that included in current DP + # List of item (FilePath) + DpModuleList = self.IpiDb.GetDpModuleList(DpGuid, DpVersion) + for Module in DpModuleList: + if Module in WsModuleList: + WsModuleList.remove(Module) + else: + Logger.Warn("UPT\n", + ST.ERR_MODULE_NOT_INSTALLED % Module) + # + # get packages in current Dp and find the install path + # List of item (PkgGuid, PkgVersion, InstallPath) + DpPackageList = self.IpiDb.GetPackageListFromDp(DpGuid, DpVersion) + DpPackagePathList = [] + WorkSP = environ["WORKSPACE"] + for (PkgName, PkgGuid, PkgVersion, DecFile) in self.WsPkgList: + if PkgName: + pass + DecPath = dirname(DecFile) + if DecPath.find(WorkSP) > -1: + InstallPath = DecPath[DecPath.find(WorkSP) + len(WorkSP) + 1:] + DecFileRelaPath = \ + DecFile[DecFile.find(WorkSP) + len(WorkSP) + 1:] + else: + InstallPath = DecPath + DecFileRelaPath = DecFile + + if (PkgGuid, PkgVersion, InstallPath) in DpPackageList: + DpPackagePathList.append(DecFileRelaPath) + DpPackageList.remove((PkgGuid, PkgVersion, InstallPath)) + + # + # the left items in DpPackageList are the packages that installed but not found anymore + # + for (PkgGuid, PkgVersion, InstallPath) in DpPackageList: + Logger.Warn("UPT", + ST.WARN_INSTALLED_PACKAGE_NOT_FOUND%(PkgGuid, PkgVersion, InstallPath)) + + # + # check modules to see if has dependency on package of current DP + # + for Module in WsModuleList: + if (CheckModuleDependFromInf(Module, DpPackagePathList)): + Removable = False + DependModuleList.append(Module) + return (Removable, DependModuleList) + + +## check whether module depends on packages in DpPackagePathList, return True +# if found, False else +# +# @param Path: a module path +# @param DpPackagePathList: a list of Package Paths +# +def CheckModuleDependFromInf(Path, DpPackagePathList): + + # + # use InfParser to parse inf, then get the information for now, + # later on, may consider only parse to get the package dependency info + # (Need to take care how to deal wit Macros) + # + WorkSP = getenv('WORKSPACE') + + try: + PomAli = InfPomAlignment(Path, WorkSP, Skip=True) + + for Item in PomAli.GetPackageDependencyList(): + if Item.GetPackageFilePath() in DpPackagePathList: + Logger.Info(ST.MSG_MODULE_DEPEND_ON % (Path, Item.GetPackageFilePath())) + return True + else: + return False + except FatalError, ErrCode: + if ErrCode.message == EDK1_INF_ERROR: + Logger.Warn("UPT", + ST.WRN_EDK1_INF_FOUND%Path) + return False + else: + return False + + + diff --git a/BaseTools/Source/Python/UPT/Core/DistributionPackageClass.py b/BaseTools/Source/Python/UPT/Core/DistributionPackageClass.py new file mode 100644 index 0000000000..0387237951 --- /dev/null +++ b/BaseTools/Source/Python/UPT/Core/DistributionPackageClass.py @@ -0,0 +1,228 @@ +## @file +# This file is used to define a class object to describe a distribution package +# +# Copyright (c) 2011, Intel Corporation. All rights reserved.
+# +# This program and the accompanying materials are licensed and made available +# under the terms and conditions of the BSD License which accompanies this +# distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +''' +DistributionPackageClass +''' + +## +# Import Modules +# +import os.path + +from Library.Misc import Sdict +from Library.Misc import GetNonMetaDataFiles +from PomAdapter.InfPomAlignment import InfPomAlignment +from PomAdapter.DecPomAlignment import DecPomAlignment +import Logger.Log as Logger +from Logger import StringTable as ST +from Logger.ToolError import OPTION_VALUE_INVALID +from Logger.ToolError import FatalError +from Logger.ToolError import EDK1_INF_ERROR +from Object.POM.CommonObject import IdentificationObject +from Object.POM.CommonObject import CommonHeaderObject +from Object.POM.CommonObject import MiscFileObject + +## DistributionPackageHeaderClass +# +# @param IdentificationObject: Identification Object +# @param CommonHeaderObject: Common Header Object +# +class DistributionPackageHeaderObject(IdentificationObject, \ + CommonHeaderObject): + def __init__(self): + IdentificationObject.__init__(self) + CommonHeaderObject.__init__(self) + self.ReadOnly = '' + self.RePackage = '' + self.Vendor = '' + self.Date = '' + self.Signature = 'Md5Sum' + self.XmlSpecification = '' + + def GetReadOnly(self): + return self.ReadOnly + + def SetReadOnly(self, ReadOnly): + self.ReadOnly = ReadOnly + + def GetRePackage(self): + return self.RePackage + + def SetRePackage(self, RePackage): + self.RePackage = RePackage + + def GetVendor(self): + return self.Vendor + + def SetDate(self, Date): + self.Date = Date + + def GetDate(self): + return self.Date + + def SetSignature(self, Signature): + self.Signature = Signature + + def GetSignature(self): + return self.Signature + + def SetXmlSpecification(self, XmlSpecification): + self.XmlSpecification = XmlSpecification + + def GetXmlSpecification(self): + return self.XmlSpecification + +## DistributionPackageClass +# +# @param object: DistributionPackageClass +# +class DistributionPackageClass(object): + def __init__(self): + self.Header = DistributionPackageHeaderObject() + # + # {(Guid, Version, Path) : PackageObj} + # + self.PackageSurfaceArea = Sdict() + # + # {(Guid, Version, Path) : ModuleObj} + # + self.ModuleSurfaceArea = Sdict() + self.Tools = MiscFileObject() + self.MiscellaneousFiles = MiscFileObject() + self.UserExtensions = [] + self.FileList = [] + + ## Get all included packages and modules for a distribution package + # + # @param WorkspaceDir: WorkspaceDir + # @param PackageList: A list of all packages + # @param ModuleList: A list of all modules + # + def GetDistributionPackage(self, WorkspaceDir, PackageList, ModuleList): + # + # Get Packages + # + if PackageList: + for PackageFile in PackageList: + PackageFileFullPath = \ + os.path.normpath(os.path.join(WorkspaceDir, PackageFile)) + DecObj = DecPomAlignment(PackageFileFullPath, WorkspaceDir, CheckMulDec = True) + PackageObj = DecObj + # + # Parser inf file one bye one + # + ModuleInfFileList = PackageObj.GetModuleFileList() + for File in ModuleInfFileList: + WsRelPath = os.path.join(PackageObj.GetPackagePath(), File) + WsRelPath = os.path.normpath(WsRelPath) + if ModuleList and WsRelPath in ModuleList: + Logger.Error("UPT", + OPTION_VALUE_INVALID, + ST.ERR_NOT_STANDALONE_MODULE_ERROR%\ + (WsRelPath, PackageFile)) + Filename = os.path.normpath\ + (os.path.join(PackageObj.GetRelaPath(), File)) + os.path.splitext(Filename) + # + # Call INF parser to generate Inf Object. + # Actually, this call is not directly call, but wrapped by + # Inf class in InfPomAlignment. + # + try: + ModuleObj = InfPomAlignment(Filename, WorkspaceDir, \ + PackageObj.GetPackagePath()) + + # + # Add module to package + # + ModuleDict = PackageObj.GetModuleDict() + ModuleDict[(ModuleObj.GetGuid(), \ + ModuleObj.GetVersion(), \ + ModuleObj.GetCombinePath())] = ModuleObj + PackageObj.SetModuleDict(ModuleDict) + except FatalError, ErrCode: + if ErrCode.message == EDK1_INF_ERROR: + Logger.Warn("UPT", + ST.WRN_EDK1_INF_FOUND%Filename) + else: + raise + + self.PackageSurfaceArea\ + [(PackageObj.GetGuid(), PackageObj.GetVersion(), \ + PackageObj.GetCombinePath())] = PackageObj + + # + # Get Modules + # + if ModuleList: + for ModuleFile in ModuleList: + ModuleFileFullPath = \ + os.path.normpath(os.path.join(WorkspaceDir, ModuleFile)) + try: + ModuleObj = InfPomAlignment(ModuleFileFullPath, + WorkspaceDir) + self.ModuleSurfaceArea[(ModuleObj.GetGuid(), \ + ModuleObj.GetVersion(), \ + ModuleObj.GetCombinePath())] = \ + ModuleObj + except FatalError, ErrCode: + if ErrCode.message == EDK1_INF_ERROR: + Logger.Error("UPT", + EDK1_INF_ERROR, + ST.WRN_EDK1_INF_FOUND%ModuleFileFullPath, + ExtraData=ST.ERR_NOT_SUPPORTED_SA_MODULE) + else: + raise + + ## Get all files included for a distribution package, except tool/misc of + # distribution level + # + # @retval DistFileList A list of filepath for NonMetaDataFile, relative to workspace + # @retval MetaDataFileList A list of filepath for MetaDataFile, relative to workspace + # + def GetDistributionFileList(self): + MetaDataFileList = [] + + for Guid, Version, Path in self.PackageSurfaceArea: + Package = self.PackageSurfaceArea[Guid, Version, Path] + PackagePath = Package.GetPackagePath() + FullPath = Package.GetFullPath() + MetaDataFileList.append(Path) + IncludePathList = Package.GetIncludePathList() + for IncludePath in IncludePathList: + SearchPath = os.path.normpath(os.path.join(os.path.dirname(FullPath), IncludePath)) + AddPath = os.path.normpath(os.path.join(PackagePath, IncludePath)) + self.FileList += GetNonMetaDataFiles(SearchPath, ['CVS', '.svn'], False, AddPath) + + Module = None + ModuleDict = Package.GetModuleDict() + for Guid, Version, Path in ModuleDict: + Module = ModuleDict[Guid, Version, Path] + ModulePath = Module.GetModulePath() + FullPath = Module.GetFullPath() + PkgRelPath = os.path.normpath(os.path.join(PackagePath, ModulePath)) + MetaDataFileList.append(Path) + self.FileList += GetNonMetaDataFiles(os.path.dirname(FullPath), ['CVS', '.svn'], False, PkgRelPath) + + for Guid, Version, Path in self.ModuleSurfaceArea: + Module = self.ModuleSurfaceArea[Guid, Version, Path] + ModulePath = Module.GetModulePath() + FullPath = Module.GetFullPath() + MetaDataFileList.append(Path) + self.FileList += GetNonMetaDataFiles(os.path.dirname(FullPath), ['CVS', '.svn'], False, ModulePath) + + return self.FileList, MetaDataFileList + + + diff --git a/BaseTools/Source/Python/UPT/Core/IpiDb.py b/BaseTools/Source/Python/UPT/Core/IpiDb.py new file mode 100644 index 0000000000..38f872c2ad --- /dev/null +++ b/BaseTools/Source/Python/UPT/Core/IpiDb.py @@ -0,0 +1,867 @@ +## @file +# This file is for installed package information database operations +# +# Copyright (c) 2011, Intel Corporation. All rights reserved.
+# +# This program and the accompanying materials are licensed and made available +# under the terms and conditions of the BSD License which accompanies this +# distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +''' +IpiDb +''' + +## +# Import Modules +# +import sqlite3 +import os.path +import time + +import Logger.Log as Logger +from Logger import StringTable as ST +from Logger.ToolError import UPT_ALREADY_RUNNING_ERROR + +## IpiDb +# +# This class represents the installed package information database +# Add/Remove/Get installed distribution package information here. +# +# +# @param object: Inherited from object class +# @param DbPath: A string for the path of the database +# +# +class IpiDatabase(object): + def __init__(self, DbPath): + Dir = os.path.dirname(DbPath) + if not os.path.isdir(Dir): + os.mkdir(Dir) + self.Conn = sqlite3.connect(DbPath, isolation_level='DEFERRED') + self.Conn.execute("PRAGMA page_size=4096") + self.Conn.execute("PRAGMA synchronous=OFF") + self.Cur = self.Conn.cursor() + self.DpTable = 'DpInfo' + self.PkgTable = 'PkgInfo' + self.ModInPkgTable = 'ModInPkgInfo' + self.StandaloneModTable = 'StandaloneModInfo' + self.ModDepexTable = 'ModDepexInfo' + self.DpFileListTable = 'DpFileListInfo' + self.DummyTable = 'Dummy' + + ## Initialize build database + # + # + def InitDatabase(self, SkipLock = False): + Logger.Verbose(ST.MSG_INIT_IPI_START) + if not SkipLock: + try: + # + # Create a dummy table, if already existed, + # then UPT is already running + # + SqlCommand = """ + create table %s ( + Dummy TEXT NOT NULL, + PRIMARY KEY (Dummy) + )""" % self.DummyTable + self.Cur.execute(SqlCommand) + self.Conn.commit() + except sqlite3.OperationalError: + Logger.Error("UPT", + UPT_ALREADY_RUNNING_ERROR, + ST.ERR_UPT_ALREADY_RUNNING_ERROR + ) + + # + # Create new table + # + SqlCommand = """ + create table IF NOT EXISTS %s ( + DpGuid TEXT NOT NULL,DpVersion TEXT NOT NULL, + InstallTime REAL NOT NULL, + NewPkgFileName TEXT NOT NULL, + PkgFileName TEXT NOT NULL, + RePackage TEXT NOT NULL, + PRIMARY KEY (DpGuid, DpVersion) + )""" % self.DpTable + self.Cur.execute(SqlCommand) + + SqlCommand = """ + create table IF NOT EXISTS %s ( + FilePath TEXT NOT NULL, + DpGuid TEXT, + DpVersion TEXT, + Md5Sum TEXT, + PRIMARY KEY (FilePath) + )""" % self.DpFileListTable + self.Cur.execute(SqlCommand) + + SqlCommand = """ + create table IF NOT EXISTS %s ( + PackageGuid TEXT NOT NULL, + PackageVersion TEXT NOT NULL, + InstallTime REAL NOT NULL, + DpGuid TEXT, + DpVersion TEXT, + InstallPath TEXT NOT NULL, + PRIMARY KEY (PackageGuid, PackageVersion, InstallPath) + )""" % self.PkgTable + self.Cur.execute(SqlCommand) + + SqlCommand = """ + create table IF NOT EXISTS %s ( + ModuleGuid TEXT NOT NULL, + ModuleVersion TEXT NOT NULL, + InstallTime REAL NOT NULL, + PackageGuid TEXT, + PackageVersion TEXT, + InstallPath TEXT NOT NULL, + PRIMARY KEY (ModuleGuid, ModuleVersion, InstallPath) + )""" % self.ModInPkgTable + self.Cur.execute(SqlCommand) + + SqlCommand = """ + create table IF NOT EXISTS %s ( + ModuleGuid TEXT NOT NULL, + ModuleVersion TEXT NOT NULL, + InstallTime REAL NOT NULL, + DpGuid TEXT, + DpVersion TEXT, + InstallPath TEXT NOT NULL, + PRIMARY KEY (ModuleGuid, ModuleVersion, InstallPath) + )""" % self.StandaloneModTable + self.Cur.execute(SqlCommand) + + SqlCommand = """ + create table IF NOT EXISTS %s ( + ModuleGuid TEXT NOT NULL, + ModuleVersion TEXT NOT NULL, + InstallPath TEXT NOT NULL, + DepexGuid TEXT, + DepexVersion TEXT + )""" % self.ModDepexTable + self.Cur.execute(SqlCommand) + + self.Conn.commit() + + Logger.Verbose(ST.MSG_INIT_IPI_FINISH) + + ## Add a distribution install information from DpObj + # + # @param DpObj: + # @param NewDpPkgFileName: New DpPkg File Name + # @param DpPkgFileName: DpPkg File Name + # @param RePackage: A RePackage + # + def AddDPObject(self, DpObj, NewDpPkgFileName, DpPkgFileName, RePackage): + + for PkgKey in DpObj.PackageSurfaceArea.keys(): + PkgGuid = PkgKey[0] + PkgVersion = PkgKey[1] + PkgInstallPath = PkgKey[2] + self._AddPackage(PkgGuid, PkgVersion, DpObj.Header.GetGuid(), \ + DpObj.Header.GetVersion(), PkgInstallPath) + PkgObj = DpObj.PackageSurfaceArea[PkgKey] + for ModKey in PkgObj.GetModuleDict().keys(): + ModGuid = ModKey[0] + ModVersion = ModKey[1] + ModInstallPath = ModKey[2] + ModInstallPath = \ + os.path.normpath(os.path.join(PkgInstallPath, ModInstallPath)) + self._AddModuleInPackage(ModGuid, ModVersion, PkgGuid, \ + PkgVersion, ModInstallPath) + ModObj = PkgObj.GetModuleDict()[ModKey] + for Dep in ModObj.GetPackageDependencyList(): + DepexGuid = Dep.GetGuid() + DepexVersion = Dep.GetVersion() + self._AddModuleDepex(ModGuid, ModVersion, ModInstallPath, \ + DepexGuid, DepexVersion) + for (FilePath, Md5Sum) in PkgObj.FileList: + self._AddDpFilePathList(DpObj.Header.GetGuid(), \ + DpObj.Header.GetVersion(), FilePath, \ + Md5Sum) + + for ModKey in DpObj.ModuleSurfaceArea.keys(): + ModGuid = ModKey[0] + ModVersion = ModKey[1] + ModInstallPath = ModKey[2] + self._AddStandaloneModule(ModGuid, ModVersion, \ + DpObj.Header.GetGuid(), \ + DpObj.Header.GetVersion(), \ + ModInstallPath) + ModObj = DpObj.ModuleSurfaceArea[ModKey] + for Dep in ModObj.GetPackageDependencyList(): + DepexGuid = Dep.GetGuid() + DepexVersion = Dep.GetVersion() + self._AddModuleDepex(ModGuid, ModVersion, ModInstallPath, \ + DepexGuid, DepexVersion) + for (Path, Md5Sum) in ModObj.FileList: + self._AddDpFilePathList(DpObj.Header.GetGuid(), \ + DpObj.Header.GetVersion(), \ + Path, Md5Sum) + + # + # add tool/misc files + # + for (Path, Md5Sum) in DpObj.FileList: + self._AddDpFilePathList(DpObj.Header.GetGuid(), \ + DpObj.Header.GetVersion(), Path, Md5Sum) + + self._AddDp(DpObj.Header.GetGuid(), DpObj.Header.GetVersion(), \ + NewDpPkgFileName, DpPkgFileName, RePackage) + + self.Conn.commit() + + ## Add a distribution install information + # + # @param Guid Guid of the distribution package + # @param Version Version of the distribution package + # @param NewDpFileName the saved filename of distribution package file + # @param DistributionFileName the filename of distribution package file + # + def _AddDp(self, Guid, Version, NewDpFileName, DistributionFileName, \ + RePackage): + + if Version == None or len(Version.strip()) == 0: + Version = 'N/A' + + # + # Add newly installed DP information to DB. + # + if NewDpFileName == None or len(NewDpFileName.strip()) == 0: + PkgFileName = 'N/A' + else: + PkgFileName = NewDpFileName + CurrentTime = time.time() + SqlCommand = \ + """insert into %s values('%s', '%s', %s, '%s', '%s', '%s')""" % \ + (self.DpTable, Guid, Version, CurrentTime, PkgFileName, \ + DistributionFileName, str(RePackage).upper()) + self.Cur.execute(SqlCommand) + + + ## Add a file list from DP + # + # @param DpGuid: A DpGuid + # @param DpVersion: A DpVersion + # @param Path: A Path + # @param Path: A Md5Sum + # + def _AddDpFilePathList(self, DpGuid, DpVersion, Path, Md5Sum): + + SqlCommand = """insert into %s values('%s', '%s', '%s', '%s')""" % \ + (self.DpFileListTable, Path, DpGuid, DpVersion, Md5Sum) + + self.Cur.execute(SqlCommand) + + ## Add a package install information + # + # @param Guid: A package guid + # @param Version: A package version + # @param DpGuid: A DpGuid + # @param DpVersion: A DpVersion + # @param Path: A Path + # + def _AddPackage(self, Guid, Version, DpGuid=None, DpVersion=None, Path=''): + + if Version == None or len(Version.strip()) == 0: + Version = 'N/A' + + if DpGuid == None or len(DpGuid.strip()) == 0: + DpGuid = 'N/A' + + if DpVersion == None or len(DpVersion.strip()) == 0: + DpVersion = 'N/A' + + # + # Add newly installed package information to DB. + # + CurrentTime = time.time() + SqlCommand = \ + """insert into %s values('%s', '%s', %s, '%s', '%s', '%s')""" % \ + (self.PkgTable, Guid, Version, CurrentTime, DpGuid, DpVersion, Path) + self.Cur.execute(SqlCommand) + + ## Add a module that from a package install information + # + # @param Guid: A package guid + # @param Version: A package version + # @param PkgGuid: A package guid + # @param PkgFileName: A package File Name + # + def _AddModuleInPackage(self, Guid, Version, PkgGuid=None, \ + PkgVersion=None, Path=''): + + if Version == None or len(Version.strip()) == 0: + Version = 'N/A' + + if PkgGuid == None or len(PkgGuid.strip()) == 0: + PkgGuid = 'N/A' + + if PkgVersion == None or len(PkgVersion.strip()) == 0: + PkgVersion = 'N/A' + + # + # Add module from package information to DB. + # + CurrentTime = time.time() + SqlCommand = \ + """insert into %s values('%s', '%s', %s, '%s', '%s', '%s')""" % \ + (self.ModInPkgTable, Guid, Version, CurrentTime, PkgGuid, PkgVersion, \ + Path) + self.Cur.execute(SqlCommand) + + ## Add a module that is standalone install information + # + # @param Guid: a module Guid + # @param Version: a module Version + # @param DpGuid: a DpGuid + # @param DpVersion: a DpVersion + # @param Path: path + # + def _AddStandaloneModule(self, Guid, Version, DpGuid=None, \ + DpVersion=None, Path=''): + + if Version == None or len(Version.strip()) == 0: + Version = 'N/A' + + if DpGuid == None or len(DpGuid.strip()) == 0: + DpGuid = 'N/A' + + if DpVersion == None or len(DpVersion.strip()) == 0: + DpVersion = 'N/A' + + # + # Add module standalone information to DB. + # + CurrentTime = time.time() + SqlCommand = \ + """insert into %s values('%s', '%s', %s, '%s', '%s', '%s')""" % \ + (self.StandaloneModTable, Guid, Version, CurrentTime, DpGuid, \ + DpVersion, Path) + self.Cur.execute(SqlCommand) + + ## Add a module depex + # + # @param Guid: a module Guid + # @param Version: a module Version + # @param DepexGuid: a module DepexGuid + # @param DepexVersion: a module DepexVersion + # + def _AddModuleDepex(self, Guid, Version, Path, DepexGuid=None, \ + DepexVersion=None): + + if DepexGuid == None or len(DepexGuid.strip()) == 0: + DepexGuid = 'N/A' + + if DepexVersion == None or len(DepexVersion.strip()) == 0: + DepexVersion = 'N/A' + + # + # Add module depex information to DB. + # + SqlCommand = """insert into %s values('%s', '%s', '%s', '%s', '%s')"""\ + % (self.ModDepexTable, Guid, Version, Path, DepexGuid, DepexVersion) + self.Cur.execute(SqlCommand) + + ## Remove a distribution install information, if no version specified, + # remove all DPs with this Guid. + # + # @param DpGuid: guid of dpex + # @param DpVersion: version of dpex + # + def RemoveDpObj(self, DpGuid, DpVersion): + + PkgList = self.GetPackageListFromDp(DpGuid, DpVersion) + # + # delete from ModDepex the standalone module's dependency + # + SqlCommand = \ + """delete from ModDepexInfo where ModDepexInfo.ModuleGuid in + (select ModuleGuid from StandaloneModInfo as B where B.DpGuid = '%s' + and B.DpVersion = '%s') + and ModDepexInfo.ModuleVersion in + (select ModuleVersion from StandaloneModInfo as B + where B.DpGuid = '%s' and B.DpVersion = '%s') + and ModDepexInfo.InstallPath in + (select InstallPath from StandaloneModInfo as B + where B.DpGuid = '%s' and B.DpVersion = '%s') """ % \ + (DpGuid, DpVersion, DpGuid, DpVersion, DpGuid, DpVersion) + + self.Cur.execute(SqlCommand) + # + # delete from ModDepex the from pkg module's dependency + # + for Pkg in PkgList: + + SqlCommand = \ + """delete from ModDepexInfo where ModDepexInfo.ModuleGuid in + (select ModuleGuid from ModInPkgInfo + where ModInPkgInfo.PackageGuid ='%s' and + ModInPkgInfo.PackageVersion = '%s') + and ModDepexInfo.ModuleVersion in + (select ModuleVersion from ModInPkgInfo + where ModInPkgInfo.PackageGuid ='%s' and + ModInPkgInfo.PackageVersion = '%s') + and ModDepexInfo.InstallPath in + (select InstallPath from ModInPkgInfo where + ModInPkgInfo.PackageGuid ='%s' + and ModInPkgInfo.PackageVersion = '%s')""" \ + % (Pkg[0], Pkg[1],Pkg[0], Pkg[1],Pkg[0], Pkg[1]) + + self.Cur.execute(SqlCommand) + # + # delete the standalone module + # + SqlCommand = \ + """delete from %s where DpGuid ='%s' and DpVersion = '%s'""" % \ + (self.StandaloneModTable, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + # + # delete the from pkg module + # + for Pkg in PkgList: + SqlCommand = \ + """delete from %s where %s.PackageGuid ='%s' + and %s.PackageVersion = '%s'""" % \ + (self.ModInPkgTable, self.ModInPkgTable, Pkg[0], \ + self.ModInPkgTable, Pkg[1]) + self.Cur.execute(SqlCommand) + # + # delete packages + # + SqlCommand = \ + """delete from %s where DpGuid ='%s' and DpVersion = '%s'""" % \ + (self.PkgTable, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + # + # delete file list from DP + # + SqlCommand = \ + """delete from %s where DpGuid ='%s' and DpVersion = '%s'""" % \ + (self.DpFileListTable, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + # + # delete DP + # + SqlCommand = \ + """delete from %s where DpGuid ='%s' and DpVersion = '%s'""" % \ + (self.DpTable, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + + self.Conn.commit() + + ## Get a list of distribution install information. + # + # @param Guid: distribution package guid + # @param Version: distribution package version + # + def GetDp(self, Guid, Version): + + if Version == None or len(Version.strip()) == 0: + Version = 'N/A' + Logger.Verbose(ST.MSG_GET_DP_INSTALL_LIST) + (DpGuid, DpVersion) = (Guid, Version) + SqlCommand = """select * from %s where DpGuid ='%s'""" % \ + (self.DpTable, DpGuid) + self.Cur.execute(SqlCommand) + + else: + Logger.Verbose(ST.MSG_GET_DP_INSTALL_INFO_START) + (DpGuid, DpVersion) = (Guid, Version) + SqlCommand = \ + """select * from %s where DpGuid ='%s' and DpVersion = '%s'""" % \ + (self.DpTable, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + + DpList = [] + for DpInfo in self.Cur: + DpGuid = DpInfo[0] + DpVersion = DpInfo[1] + InstallTime = DpInfo[2] + PkgFileName = DpInfo[3] + DpList.append((DpGuid, DpVersion, InstallTime, PkgFileName)) + + Logger.Verbose(ST.MSG_GET_DP_INSTALL_INFO_FINISH) + return DpList + + ## Get a list of distribution install dirs + # + # @param Guid: distribution package guid + # @param Version: distribution package version + # + def GetDpInstallDirList(self, Guid, Version): + SqlCommand = """select InstallPath from PkgInfo where DpGuid = '%s' and DpVersion = '%s'""" % (Guid, Version) + self.Cur.execute(SqlCommand) + DirList = [] + for Result in self.Cur: + if Result[0] not in DirList: + DirList.append(Result[0]) + + SqlCommand = """select InstallPath from StandaloneModInfo where DpGuid = '%s' and DpVersion = '%s'""" % \ + (Guid, Version) + self.Cur.execute(SqlCommand) + for Result in self.Cur: + if Result[0] not in DirList: + DirList.append(Result[0]) + + return DirList + + + ## Get a list of distribution install file path information. + # + # @param Guid: distribution package guid + # @param Version: distribution package version + # + def GetDpFileList(self, Guid, Version): + + (DpGuid, DpVersion) = (Guid, Version) + SqlCommand = \ + """select * from %s where DpGuid ='%s' and DpVersion = '%s'""" % \ + (self.DpFileListTable, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + + PathList = [] + for Result in self.Cur: + Path = Result[0] + Md5Sum = Result[3] + PathList.append((Path, Md5Sum)) + + return PathList + + ## Get files' repackage attribute if present that are installed into current workspace + # + # @retval FileDict: a Dict of file, key is file path, value is (DpGuid, DpVersion, NewDpFileName, RePackage) + # + def GetRePkgDict(self): + SqlCommand = """select * from %s """ % (self.DpTable) + self.Cur.execute(SqlCommand) + + DpInfoList = [] + for Result in self.Cur: + DpInfoList.append(Result) + + FileDict = {} + for Result in DpInfoList: + DpGuid = Result[0] + DpVersion = Result[1] + NewDpFileName = Result[3] + RePackage = Result[5] + if RePackage == 'TRUE': + RePackage = True + else: + RePackage = False + for FileInfo in self.GetDpFileList(DpGuid, DpVersion): + PathInfo = FileInfo[0] + FileDict[PathInfo] = DpGuid, DpVersion, NewDpFileName, RePackage + + return FileDict + + ## Get (Guid, Version) from distribution file name information. + # + # @param DistributionFile: Distribution File + # + def GetDpByName(self, DistributionFile): + SqlCommand = """select * from %s where NewPkgFileName like '%s'""" % \ + (self.DpTable, '%' + DistributionFile) + self.Cur.execute(SqlCommand) + + for Result in self.Cur: + DpGuid = Result[0] + DpVersion = Result[1] + NewDpFileName = Result[3] + + return (DpGuid, DpVersion, NewDpFileName) + else: + return (None, None, None) + + ## Get a list of package information. + # + # @param Guid: package guid + # @param Version: package version + # + def GetPackage(self, Guid, Version, DpGuid='', DpVersion=''): + + if DpVersion == '' or DpGuid == '': + + (PackageGuid, PackageVersion) = (Guid, Version) + SqlCommand = """select * from %s where PackageGuid ='%s' + and PackageVersion = '%s'""" % (self.PkgTable, PackageGuid, \ + PackageVersion) + self.Cur.execute(SqlCommand) + + elif Version == None or len(Version.strip()) == 0: + + SqlCommand = """select * from %s where PackageGuid ='%s'""" % \ + (self.PkgTable, Guid) + self.Cur.execute(SqlCommand) + else: + (PackageGuid, PackageVersion) = (Guid, Version) + SqlCommand = """select * from %s where PackageGuid ='%s' and + PackageVersion = '%s' + and DpGuid = '%s' and DpVersion = '%s'""" % \ + (self.PkgTable, PackageGuid, PackageVersion, \ + DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + + PkgList = [] + for PkgInfo in self.Cur: + PkgGuid = PkgInfo[0] + PkgVersion = PkgInfo[1] + InstallTime = PkgInfo[2] + InstallPath = PkgInfo[5] + PkgList.append((PkgGuid, PkgVersion, InstallTime, DpGuid, \ + DpVersion, InstallPath)) + + return PkgList + + + ## Get a list of module in package information. + # + # @param Guid: A module guid + # @param Version: A module version + # + def GetModInPackage(self, Guid, Version, PkgGuid='', PkgVersion=''): + + if PkgVersion == '' or PkgGuid == '': + + (ModuleGuid, ModuleVersion) = (Guid, Version) + SqlCommand = """select * from %s where ModuleGuid ='%s' and + ModuleVersion = '%s'""" % (self.ModInPkgTable, ModuleGuid, \ + ModuleVersion) + self.Cur.execute(SqlCommand) + + else: + (ModuleGuid, ModuleVersion) = (Guid, Version) + SqlCommand = """select * from %s where ModuleGuid ='%s' and + ModuleVersion = '%s' and PackageGuid ='%s' + and PackageVersion = '%s' + """ % (self.ModInPkgTable, ModuleGuid, \ + ModuleVersion, PkgGuid, PkgVersion) + self.Cur.execute(SqlCommand) + + ModList = [] + for ModInfo in self.Cur: + ModGuid = ModInfo[0] + ModVersion = ModInfo[1] + InstallTime = ModInfo[2] + InstallPath = ModInfo[5] + ModList.append((ModGuid, ModVersion, InstallTime, PkgGuid, \ + PkgVersion, InstallPath)) + + return ModList + + ## Get a list of module standalone. + # + # @param Guid: A module guid + # @param Version: A module version + # + def GetStandaloneModule(self, Guid, Version, DpGuid='', DpVersion=''): + + if DpGuid == '': + (ModuleGuid, ModuleVersion) = (Guid, Version) + SqlCommand = """select * from %s where ModuleGuid ='%s' and + ModuleVersion = '%s'""" % (self.StandaloneModTable, ModuleGuid, \ + ModuleVersion) + self.Cur.execute(SqlCommand) + + else: + (ModuleGuid, ModuleVersion) = (Guid, Version) + SqlCommand = """select * from %s where ModuleGuid ='%s' and + ModuleVersion = '%s' and DpGuid ='%s' and DpVersion = '%s' + """ % (self.StandaloneModTable, ModuleGuid, \ + ModuleVersion, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + + ModList = [] + for ModInfo in self.Cur: + ModGuid = ModInfo[0] + ModVersion = ModInfo[1] + InstallTime = ModInfo[2] + InstallPath = ModInfo[5] + ModList.append((ModGuid, ModVersion, InstallTime, DpGuid, \ + DpVersion, InstallPath)) + + return ModList + + ## Get a list of module information that comes from DP. + # + # @param DpGuid: A Distrabution Guid + # @param DpVersion: A Distrabution version + # + def GetSModInsPathListFromDp(self, DpGuid, DpVersion): + + PathList = [] + SqlCommand = """select InstallPath from %s where DpGuid ='%s' + and DpVersion = '%s' + """ % (self.StandaloneModTable, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + + for Result in self.Cur: + InstallPath = Result[0] + PathList.append(InstallPath) + + return PathList + + ## Get a list of package information. + # + # @param DpGuid: A Distrabution Guid + # @param DpVersion: A Distrabution version + # + def GetPackageListFromDp(self, DpGuid, DpVersion): + + SqlCommand = """select * from %s where DpGuid ='%s' and + DpVersion = '%s' """ % (self.PkgTable, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + + PkgList = [] + for PkgInfo in self.Cur: + PkgGuid = PkgInfo[0] + PkgVersion = PkgInfo[1] + InstallPath = PkgInfo[5] + PkgList.append((PkgGuid, PkgVersion, InstallPath)) + + return PkgList + + ## Get a list of modules that depends on package information from a DP. + # + # @param DpGuid: A Distrabution Guid + # @param DpVersion: A Distrabution version + # + def GetDpDependentModuleList(self, DpGuid, DpVersion): + + ModList = [] + PkgList = self.GetPackageListFromDp(DpGuid, DpVersion) + if len(PkgList) > 0: + return ModList + + for Pkg in PkgList: + # + # get all in-package modules that depends on current + # Pkg (Guid match, Version match or NA) but not belong to + # current Pkg + # + SqlCommand = """select t1.ModuleGuid, t1.ModuleVersion, + t1.InstallPath from %s as t1, %s as t2 where + t1.ModuleGuid = t2.ModuleGuid and + t1.ModuleVersion = t2.ModuleVersion and t2.DepexGuid ='%s' + and (t2.DepexVersion = '%s' or t2.DepexVersion = 'N/A') and + t1.PackageGuid != '%s' and t1.PackageVersion != '%s' + """ % (self.ModInPkgTable, \ + self.ModDepexTable, Pkg[0], Pkg[1], Pkg[0], \ + Pkg[1]) + self.Cur.execute(SqlCommand) + for ModInfo in self.Cur: + ModGuid = ModInfo[0] + ModVersion = ModInfo[1] + InstallPath = ModInfo[2] + ModList.append((ModGuid, ModVersion, InstallPath)) + + # + # get all modules from standalone modules that depends on current + #Pkg (Guid match, Version match or NA) but not in current dp + # + SqlCommand = \ + """select t1.ModuleGuid, t1.ModuleVersion, t1.InstallPath + from %s as t1, %s as t2 where t1.ModuleGuid = t2.ModuleGuid and + t1.ModuleVersion = t2.ModuleVersion and t2.DepexGuid ='%s' + and (t2.DepexVersion = '%s' or t2.DepexVersion = 'N/A') and + t1.DpGuid != '%s' and t1.DpVersion != '%s' + """ % \ + (self.StandaloneModTable, self.ModDepexTable, Pkg[0], \ + Pkg[1], DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + for ModInfo in self.Cur: + ModGuid = ModInfo[0] + ModVersion = ModInfo[1] + InstallPath = ModInfo[2] + ModList.append((ModGuid, ModVersion, InstallPath)) + + + return ModList + + ## Get Dp's list of modules. + # + # @param DpGuid: A Distrabution Guid + # @param DpVersion: A Distrabution version + # + def GetDpModuleList(self, DpGuid, DpVersion): + ModList = [] + # + # get Dp module list from the DpFileList table + # + SqlCommand = """select FilePath + from %s + where DpGuid = '%s' and DpVersion = '%s' and + FilePath like '%%.inf' + """ % (self.DpFileListTable, DpGuid, DpVersion) + self.Cur.execute(SqlCommand) + for ModuleInfo in self.Cur: + FilePath = ModuleInfo[0] + ModList.append(FilePath) + + return ModList + + + ## Get a module depex + # + # @param DpGuid: A module Guid + # @param DpVersion: A module version + # @param Path: + # + def GetModuleDepex(self, Guid, Version, Path): + + # + # Get module depex information to DB. + # + SqlCommand = """select * from %s where ModuleGuid ='%s' and + ModuleVersion = '%s' and InstallPath ='%s' + """ % (self.ModDepexTable, Guid, Version, Path) + self.Cur.execute(SqlCommand) + self.Conn.commit() + + DepexList = [] + for DepInfo in self.Cur: + DepexGuid = DepInfo[3] + DepexVersion = DepInfo[4] + DepexList.append((DepexGuid, DepexVersion)) + + return DepexList + + ## Close entire database + # + # Close the connection and cursor + # + def CloseDb(self): + # + # drop the dummy table + # + SqlCommand = """ + drop table IF EXISTS %s + """ % self.DummyTable + self.Cur.execute(SqlCommand) + self.Conn.commit() + + self.Cur.close() + self.Conn.close() + + ## Convert To Sql String + # + # 1. Replace "'" with "''" in each item of StringList + # + # @param StringList: A list for strings to be converted + # + def __ConvertToSqlString(self, StringList): + if self.DpTable: + pass + return map(lambda s: s.replace("'", "''") , StringList) + + + + \ No newline at end of file diff --git a/BaseTools/Source/Python/UPT/Core/PackageFile.py b/BaseTools/Source/Python/UPT/Core/PackageFile.py new file mode 100644 index 0000000000..04c5d4e8d0 --- /dev/null +++ b/BaseTools/Source/Python/UPT/Core/PackageFile.py @@ -0,0 +1,249 @@ +## @file +# +# PackageFile class represents the zip file of a distribution package. +# +# Copyright (c) 2011, Intel Corporation. All rights reserved.
+# +# This program and the accompanying materials are licensed and made available +# under the terms and conditions of the BSD License which accompanies this +# distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +''' +PackageFile +''' + +## +# Import Modules +# +import os.path +import zipfile +import tempfile +import platform + +from Logger.ToolError import FILE_OPEN_FAILURE +from Logger.ToolError import FILE_CHECKSUM_FAILURE +from Logger.ToolError import FILE_NOT_FOUND +from Logger.ToolError import FILE_DECOMPRESS_FAILURE +from Logger.ToolError import FILE_UNKNOWN_ERROR +from Logger.ToolError import FILE_WRITE_FAILURE +from Logger.ToolError import FILE_COMPRESS_FAILURE +import Logger.Log as Logger +from Logger import StringTable as ST +from Library.Misc import CreateDirectory +from Library.Misc import RemoveDirectory + + + +class PackageFile: + def __init__(self, FileName, Mode="r"): + self._FileName = FileName + if Mode not in ["r", "w", "a"]: + Mode = "r" + try: + self._ZipFile = zipfile.ZipFile(FileName, Mode, \ + zipfile.ZIP_DEFLATED) + self._Files = {} + for Filename in self._ZipFile.namelist(): + self._Files[os.path.normpath(Filename)] = Filename + except BaseException, Xstr: + Logger.Error("PackagingTool", FILE_OPEN_FAILURE, + ExtraData="%s (%s)" % (FileName, str(Xstr))) + + BadFile = self._ZipFile.testzip() + if BadFile != None: + Logger.Error("PackagingTool", FILE_CHECKSUM_FAILURE, + ExtraData="[%s] in %s" % (BadFile, FileName)) + + def GetZipFile(self): + return self._ZipFile + + ## Get file name + # + def __str__(self): + return self._FileName + + ## Extract the file + # + # @param To: the destination file + # + def Unpack(self, ToDest): + for FileN in self._ZipFile.namelist(): + ToFile = os.path.normpath(os.path.join(ToDest, FileN)) + Msg = "%s -> %s" % (FileN, ToFile) + Logger.Info(Msg) + self.Extract(FileN, ToFile) + + ## Extract the file + # + # @param File: the extracted file + # @param ToFile: the destination file + # + def UnpackFile(self, File, ToFile): + File = File.replace('\\', '/') + if File in self._ZipFile.namelist(): + Msg = "%s -> %s" % (File, ToFile) + Logger.Info(Msg) + self.Extract(File, ToFile) + return ToFile + + return '' + + ## Extract the file + # + # @param Which: the source path + # @param To: the destination path + # + def Extract(self, Which, ToDest): + Which = os.path.normpath(Which) + if Which not in self._Files: + Logger.Error("PackagingTool", FILE_NOT_FOUND, + ExtraData="[%s] in %s" % (Which, self._FileName)) + try: + FileContent = self._ZipFile.read(self._Files[Which]) + except BaseException, Xstr: + Logger.Error("PackagingTool", FILE_DECOMPRESS_FAILURE, + ExtraData="[%s] in %s (%s)" % (Which, \ + self._FileName, \ + str(Xstr))) + try: + CreateDirectory(os.path.dirname(ToDest)) + if os.path.exists(ToDest) and not os.access(ToDest, os.W_OK): + Logger.Warn("PackagingTool", \ + ST.WRN_FILE_NOT_OVERWRITTEN % ToDest) + return + ToFile = open(ToDest, "wb") + except BaseException, Xstr: + Logger.Error("PackagingTool", FILE_OPEN_FAILURE, + ExtraData="%s (%s)" % (ToDest, str(Xstr))) + + try: + ToFile.write(FileContent) + ToFile.close() + except BaseException, Xstr: + Logger.Error("PackagingTool", FILE_WRITE_FAILURE, + ExtraData="%s (%s)" % (ToDest, str(Xstr))) + + ## Remove the file + # + # @param Files: the removed files + # + def Remove(self, Files): + TmpDir = os.path.join(tempfile.gettempdir(), ".packaging") + if os.path.exists(TmpDir): + RemoveDirectory(TmpDir, True) + + os.mkdir(TmpDir) + self.Unpack(TmpDir) + for SinF in Files: + SinF = os.path.normpath(SinF) + if SinF not in self._Files: + Logger.Error("PackagingTool", FILE_NOT_FOUND, + ExtraData="%s is not in %s!" % \ + (SinF, self._FileName)) + self._Files.pop(SinF) + self._ZipFile.close() + + self._ZipFile = zipfile.ZipFile(self._FileName, "w", \ + zipfile.ZIP_DEFLATED) + Cwd = os.getcwd() + os.chdir(TmpDir) + self.PackFiles(self._Files) + os.chdir(Cwd) + RemoveDirectory(TmpDir, True) + + ## Pack the files under Top directory, the directory shown in the zipFile start from BaseDir, + # BaseDir should be the parent directory of the Top directory, for example, + # Pack(Workspace\Dir1, Workspace) will pack files under Dir1, and the path in the zipfile will + # start from Workspace + # + # @param Top: the top directory + # @param BaseDir: the base directory + # + def Pack(self, Top, BaseDir): + if not os.path.isdir(Top): + Logger.Error("PackagingTool", FILE_UNKNOWN_ERROR, \ + "%s is not a directory!" %Top) + + FilesToPack = [] + Cwd = os.getcwd() + os.chdir(BaseDir) + RelaDir = Top[Top.upper().find(BaseDir.upper()).\ + join(len(BaseDir).join(1)):] + + for Root, Dirs, Files in os.walk(RelaDir): + if 'CVS' in Dirs: + Dirs.remove('CVS') + if '.svn' in Dirs: + Dirs.remove('.svn') + + for Dir in Dirs: + if Dir.startswith('.'): + Dirs.remove(Dir) + for File1 in Files: + if File1.startswith('.'): + continue + ExtName = os.path.splitext(File1)[1] + # + # skip '.dec', '.inf', '.dsc', '.fdf' files + # + if ExtName.lower() in ['.dec', '.inf', '.dsc', '.fdf']: + continue + FilesToPack.append(os.path.join(Root, File1)) + self.PackFiles(FilesToPack) + os.chdir(Cwd) + + ## Pack the file + # + # @param Files: the files to pack + # + def PackFiles(self, Files): + for File1 in Files: + self.PackFile(File1) + + ## Pack the file + # + # @param File: the files to pack + # @param ArcName: the Arc Name + # + def PackFile(self, File, ArcName=None): + try: + # + # avoid packing same file multiple times + # + if platform.system() != 'Windows': + File = File.replace('\\', '/') + ZipedFilesNameList = self._ZipFile.namelist() + for ZipedFile in ZipedFilesNameList: + if File == os.path.normpath(ZipedFile): + return + Logger.Info("packing ..." + File) + self._ZipFile.write(File, ArcName) + except BaseException, Xstr: + Logger.Error("PackagingTool", FILE_COMPRESS_FAILURE, + ExtraData="%s (%s)" % (File, str(Xstr))) + + ## Write data to the packed file + # + # @param Data: data to write + # @param ArcName: the Arc Name + # + def PackData(self, Data, ArcName): + try: + self._ZipFile.writestr(ArcName, Data) + except BaseException, Xstr: + Logger.Error("PackagingTool", FILE_COMPRESS_FAILURE, + ExtraData="%s (%s)" % (ArcName, str(Xstr))) + + ## Close file + # + # + def Close(self): + self._ZipFile.close() + + + diff --git a/BaseTools/Source/Python/UPT/Core/__init__.py b/BaseTools/Source/Python/UPT/Core/__init__.py new file mode 100644 index 0000000000..39c78e8ecf --- /dev/null +++ b/BaseTools/Source/Python/UPT/Core/__init__.py @@ -0,0 +1,20 @@ +## @file +# Python 'Library' package initialization file. +# +# This file is required to make Python interpreter treat the directory +# as containing package. +# +# Copyright (c) 2011, Intel Corporation. All rights reserved.
+# +# This program and the accompanying materials are licensed and made available +# under the terms and conditions of the BSD License which accompanies this +# distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +''' +Core init file +''' \ No newline at end of file -- cgit v1.2.3