| ## @file | |
| # This file is for installed package information database operations | |
| # | |
| # Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR> | |
| # | |
| # SPDX-License-Identifier: BSD-2-Clause-Patent | |
| # | |
| ''' | |
| 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 | |
| from Logger.ToolError import UPT_DB_UPDATE_ERROR | |
| import platform as pf | |
| ## 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, Workspace): | |
| Dir = os.path.dirname(DbPath) | |
| if not os.path.isdir(Dir): | |
| os.mkdir(Dir) | |
| self.Conn = sqlite3.connect(u''.join(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' | |
| self.Workspace = os.path.normpath(Workspace) | |
| ## 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, | |
| ModuleName TEXT NOT NULL, | |
| InstallTime REAL NOT NULL, | |
| PackageGuid TEXT, | |
| PackageVersion TEXT, | |
| InstallPath TEXT NOT NULL, | |
| PRIMARY KEY (ModuleGuid, ModuleVersion, ModuleName, InstallPath) | |
| )""" % self.ModInPkgTable | |
| self.Cur.execute(SqlCommand) | |
| SqlCommand = """ | |
| create table IF NOT EXISTS %s ( | |
| ModuleGuid TEXT NOT NULL, | |
| ModuleVersion TEXT NOT NULL, | |
| ModuleName TEXT NOT NULL, | |
| InstallTime REAL NOT NULL, | |
| DpGuid TEXT, | |
| DpVersion TEXT, | |
| InstallPath TEXT NOT NULL, | |
| PRIMARY KEY (ModuleGuid, ModuleVersion, ModuleName, InstallPath) | |
| )""" % self.StandaloneModTable | |
| self.Cur.execute(SqlCommand) | |
| SqlCommand = """ | |
| create table IF NOT EXISTS %s ( | |
| ModuleGuid TEXT NOT NULL, | |
| ModuleVersion TEXT NOT NULL, | |
| ModuleName 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) | |
| def RollBack(self): | |
| self.Conn.rollback() | |
| def Commit(self): | |
| self.Conn.commit() | |
| ## 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): | |
| try: | |
| 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] | |
| ModName = ModKey[2] | |
| ModInstallPath = ModKey[3] | |
| ModInstallPath = \ | |
| os.path.normpath(os.path.join(PkgInstallPath, ModInstallPath)) | |
| self._AddModuleInPackage(ModGuid, ModVersion, ModName, PkgGuid, \ | |
| PkgVersion, ModInstallPath) | |
| ModObj = PkgObj.GetModuleDict()[ModKey] | |
| for Dep in ModObj.GetPackageDependencyList(): | |
| DepexGuid = Dep.GetGuid() | |
| DepexVersion = Dep.GetVersion() | |
| self._AddModuleDepex(ModGuid, ModVersion, ModName, 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] | |
| ModName = ModKey[2] | |
| ModInstallPath = ModKey[3] | |
| self._AddStandaloneModule(ModGuid, ModVersion, ModName, \ | |
| 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, ModName, 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) | |
| except sqlite3.IntegrityError as DetailMsg: | |
| Logger.Error("UPT", | |
| UPT_DB_UPDATE_ERROR, | |
| ST.ERR_UPT_DB_UPDATE_ERROR, | |
| ExtraData = DetailMsg | |
| ) | |
| ## 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 is None or len(Version.strip()) == 0: | |
| Version = 'N/A' | |
| # | |
| # Add newly installed DP information to DB. | |
| # | |
| if NewDpFileName is 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): | |
| Path = os.path.normpath(Path) | |
| if pf.system() == 'Windows': | |
| if Path.startswith(self.Workspace): | |
| Path = Path[len(self.Workspace):] | |
| else: | |
| if Path.startswith(self.Workspace + os.sep): | |
| Path = Path[len(self.Workspace)+1:] | |
| 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 is None or len(Version.strip()) == 0: | |
| Version = 'N/A' | |
| if DpGuid is None or len(DpGuid.strip()) == 0: | |
| DpGuid = 'N/A' | |
| if DpVersion is 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: Module Guid | |
| # @param Version: Module version | |
| # @param Name: Module Name | |
| # @param PkgGuid: Package Guid | |
| # @param PkgVersion: Package version | |
| # @param Path: Package relative path that module installs | |
| # | |
| def _AddModuleInPackage(self, Guid, Version, Name, PkgGuid=None, \ | |
| PkgVersion=None, Path=''): | |
| if Version is None or len(Version.strip()) == 0: | |
| Version = 'N/A' | |
| if PkgGuid is None or len(PkgGuid.strip()) == 0: | |
| PkgGuid = 'N/A' | |
| if PkgVersion is None or len(PkgVersion.strip()) == 0: | |
| PkgVersion = 'N/A' | |
| if os.name == 'posix': | |
| Path = Path.replace('\\', os.sep) | |
| else: | |
| Path = Path.replace('/', os.sep) | |
| # | |
| # Add module from package information to DB. | |
| # | |
| CurrentTime = time.time() | |
| SqlCommand = \ | |
| """insert into %s values('%s', '%s', '%s', %s, '%s', '%s', '%s')""" % \ | |
| (self.ModInPkgTable, Guid, Version, Name, 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 Name: a module name | |
| # @param DpGuid: a DpGuid | |
| # @param DpVersion: a DpVersion | |
| # @param Path: path | |
| # | |
| def _AddStandaloneModule(self, Guid, Version, Name, DpGuid=None, \ | |
| DpVersion=None, Path=''): | |
| if Version is None or len(Version.strip()) == 0: | |
| Version = 'N/A' | |
| if DpGuid is None or len(DpGuid.strip()) == 0: | |
| DpGuid = 'N/A' | |
| if DpVersion is 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', '%s')""" % \ | |
| (self.StandaloneModTable, Guid, Version, Name, CurrentTime, DpGuid, \ | |
| DpVersion, Path) | |
| self.Cur.execute(SqlCommand) | |
| ## Add a module depex | |
| # | |
| # @param Guid: a module Guid | |
| # @param Version: a module Version | |
| # @param Name: a module name | |
| # @param DepexGuid: a module DepexGuid | |
| # @param DepexVersion: a module DepexVersion | |
| # | |
| def _AddModuleDepex(self, Guid, Version, Name, Path, DepexGuid=None, \ | |
| DepexVersion=None): | |
| if DepexGuid is None or len(DepexGuid.strip()) == 0: | |
| DepexGuid = 'N/A' | |
| if DepexVersion is None or len(DepexVersion.strip()) == 0: | |
| DepexVersion = 'N/A' | |
| if os.name == 'posix': | |
| Path = Path.replace('\\', os.sep) | |
| else: | |
| Path = Path.replace('/', os.sep) | |
| # | |
| # Add module depex information to DB. | |
| # | |
| SqlCommand = """insert into %s values('%s', '%s', '%s', '%s', '%s', '%s')"""\ | |
| % (self.ModDepexTable, Guid, Version, Name, 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.ModuleName in | |
| (select ModuleName 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, 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.ModuleName in | |
| (select ModuleName 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], 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 is 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((os.path.join(self.Workspace, 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 = '%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 is 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, Name, Path, PkgGuid='', PkgVersion=''): | |
| (ModuleGuid, ModuleVersion, ModuleName, InstallPath) = (Guid, Version, Name, Path) | |
| if PkgVersion == '' or PkgGuid == '': | |
| SqlCommand = """select * from %s where ModuleGuid ='%s' and | |
| ModuleVersion = '%s' and InstallPath = '%s' | |
| and ModuleName = '%s'""" % (self.ModInPkgTable, ModuleGuid, \ | |
| ModuleVersion, InstallPath, ModuleName) | |
| self.Cur.execute(SqlCommand) | |
| else: | |
| SqlCommand = """select * from %s where ModuleGuid ='%s' and | |
| ModuleVersion = '%s' and InstallPath = '%s' | |
| and ModuleName = '%s' and PackageGuid ='%s' | |
| and PackageVersion = '%s' | |
| """ % (self.ModInPkgTable, ModuleGuid, \ | |
| ModuleVersion, InstallPath, ModuleName, 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, Name, Path, DpGuid='', DpVersion=''): | |
| (ModuleGuid, ModuleVersion, ModuleName, InstallPath) = (Guid, Version, Name, Path) | |
| if DpGuid == '': | |
| SqlCommand = """select * from %s where ModuleGuid ='%s' and | |
| ModuleVersion = '%s' and InstallPath = '%s' | |
| and ModuleName = '%s'""" % (self.StandaloneModTable, ModuleGuid, \ | |
| ModuleVersion, InstallPath, ModuleName) | |
| self.Cur.execute(SqlCommand) | |
| else: | |
| SqlCommand = """select * from %s where ModuleGuid ='%s' and | |
| ModuleVersion = '%s' and InstallPath = '%s' and ModuleName = '%s' and DpGuid ='%s' and DpVersion = '%s' | |
| """ % (self.StandaloneModTable, ModuleGuid, \ | |
| ModuleVersion, ModuleName, InstallPath, 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 Distribution Guid | |
| # @param DpVersion: A Distribution 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 Distribution Guid | |
| # @param DpVersion: A Distribution 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 Distribution Guid | |
| # @param DpVersion: A Distribution 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 Distribution Guid | |
| # @param DpVersion: A Distribution 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(os.path.join(self.Workspace, 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) | |
| DepexList = [] | |
| for DepInfo in self.Cur: | |
| DepexGuid = DepInfo[3] | |
| DepexVersion = DepInfo[4] | |
| DepexList.append((DepexGuid, DepexVersion)) | |
| return DepexList | |
| ## Inventory the distribution installed to current workspace | |
| # | |
| # Inventory the distribution installed to current workspace | |
| # | |
| def InventoryDistInstalled(self): | |
| SqlCommand = """select * from %s """ % (self.DpTable) | |
| self.Cur.execute(SqlCommand) | |
| DpInfoList = [] | |
| for Result in self.Cur: | |
| DpGuid = Result[0] | |
| DpVersion = Result[1] | |
| DpAliasName = Result[3] | |
| DpFileName = Result[4] | |
| DpInfoList.append((DpGuid, DpVersion, DpFileName, DpAliasName)) | |
| return DpInfoList | |
| ## 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 list(map(lambda s: s.replace("'", "''"), StringList)) | |