[mirror_edk2.git] / BaseTools / Source / Python / UPT / Core / IpiDb.py

## @file\r
# This file is for installed package information database operations\r
#\r
# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available \r
# under the terms and conditions of the BSD License which accompanies this \r
# distribution. The full text of the license may be found at \r
# http://opensource.org/licenses/bsd-license.php\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
'''\r
IpiDb\r
'''\r
\r
##\r
# Import Modules\r
#\r
import sqlite3\r
import os.path\r
import time\r
\r
import Logger.Log as Logger\r
from Logger import StringTable as ST\r
from Logger.ToolError import UPT_ALREADY_RUNNING_ERROR\r
\r
## IpiDb\r
#\r
# This class represents the installed package information database\r
# Add/Remove/Get installed distribution package information here.\r
# \r
# \r
# @param object:      Inherited from object class\r
# @param DbPath:      A string for the path of the database\r
#\r
#\r
class IpiDatabase(object):\r
    def __init__(self, DbPath):\r
        Dir = os.path.dirname(DbPath)\r
        if not os.path.isdir(Dir):\r
            os.mkdir(Dir)\r
        self.Conn = sqlite3.connect(DbPath, isolation_level='DEFERRED')\r
        self.Conn.execute("PRAGMA page_size=4096")\r
        self.Conn.execute("PRAGMA synchronous=OFF")\r
        self.Cur = self.Conn.cursor()\r
        self.DpTable = 'DpInfo'\r
        self.PkgTable = 'PkgInfo'\r
        self.ModInPkgTable = 'ModInPkgInfo'\r
        self.StandaloneModTable = 'StandaloneModInfo'\r
        self.ModDepexTable = 'ModDepexInfo'\r
        self.DpFileListTable = 'DpFileListInfo'\r
        self.DummyTable = 'Dummy'\r
\r
    ## Initialize build database\r
    #\r
    #\r
    def InitDatabase(self, SkipLock = False):\r
        Logger.Verbose(ST.MSG_INIT_IPI_START)\r
        if not SkipLock:\r
            try:\r
                #\r
                # Create a dummy table, if already existed,\r
                # then UPT is already running\r
                #\r
                SqlCommand = """\r
                create table %s (\r
                Dummy TEXT NOT NULL,\r
                PRIMARY KEY (Dummy)                                               \r
                )""" % self.DummyTable\r
                self.Cur.execute(SqlCommand)\r
                self.Conn.commit()\r
            except sqlite3.OperationalError:\r
                Logger.Error("UPT", \r
                             UPT_ALREADY_RUNNING_ERROR, \r
                             ST.ERR_UPT_ALREADY_RUNNING_ERROR\r
                             )\r
        \r
        #\r
        # Create new table\r
        #\r
        SqlCommand = """\r
        create table IF NOT EXISTS %s (\r
        DpGuid TEXT NOT NULL,DpVersion TEXT NOT NULL,\r
        InstallTime REAL NOT NULL,\r
        NewPkgFileName TEXT NOT NULL,\r
        PkgFileName TEXT NOT NULL,                                               \r
        RePackage TEXT NOT NULL,\r
        PRIMARY KEY (DpGuid, DpVersion)                                               \r
        )""" % self.DpTable\r
        self.Cur.execute(SqlCommand)\r
        \r
        SqlCommand = """\r
        create table IF NOT EXISTS %s (\r
        FilePath TEXT NOT NULL,\r
        DpGuid TEXT,\r
        DpVersion TEXT,\r
        Md5Sum TEXT,\r
        PRIMARY KEY (FilePath)\r
        )""" % self.DpFileListTable\r
        self.Cur.execute(SqlCommand)\r
        \r
        SqlCommand = """\r
        create table IF NOT EXISTS %s (\r
        PackageGuid TEXT NOT NULL,\r
        PackageVersion TEXT NOT NULL,\r
        InstallTime REAL NOT NULL,\r
        DpGuid TEXT,\r
        DpVersion TEXT,\r
        InstallPath TEXT NOT NULL,\r
        PRIMARY KEY (PackageGuid, PackageVersion, InstallPath)\r
        )""" % self.PkgTable\r
        self.Cur.execute(SqlCommand)\r
                \r
        SqlCommand = """\r
        create table IF NOT EXISTS %s (\r
        ModuleGuid TEXT NOT NULL,\r
        ModuleVersion TEXT NOT NULL,\r
        InstallTime REAL NOT NULL,\r
        PackageGuid TEXT,\r
        PackageVersion TEXT,\r
        InstallPath TEXT NOT NULL,\r
        PRIMARY KEY (ModuleGuid, ModuleVersion, InstallPath)\r
        )""" % self.ModInPkgTable\r
        self.Cur.execute(SqlCommand)\r
        \r
        SqlCommand = """\r
        create table IF NOT EXISTS %s (\r
        ModuleGuid TEXT NOT NULL,\r
        ModuleVersion TEXT NOT NULL,\r
        InstallTime REAL NOT NULL,\r
        DpGuid TEXT,\r
        DpVersion TEXT,\r
        InstallPath TEXT NOT NULL,\r
        PRIMARY KEY (ModuleGuid, ModuleVersion, InstallPath)\r
        )""" % self.StandaloneModTable\r
        self.Cur.execute(SqlCommand)\r
        \r
        SqlCommand = """\r
        create table IF NOT EXISTS %s (\r
        ModuleGuid TEXT NOT NULL,\r
        ModuleVersion TEXT NOT NULL,\r
        InstallPath TEXT NOT NULL,\r
        DepexGuid TEXT,\r
        DepexVersion TEXT\r
        )""" % self.ModDepexTable\r
        self.Cur.execute(SqlCommand)\r
        \r
        self.Conn.commit()\r
        \r
        Logger.Verbose(ST.MSG_INIT_IPI_FINISH)\r
\r
    ## Add a distribution install information from DpObj\r
    #\r
    # @param DpObj:\r
    # @param NewDpPkgFileName: New DpPkg File Name\r
    # @param DpPkgFileName: DpPkg File Name\r
    # @param RePackage: A RePackage\r
    #\r
    def AddDPObject(self, DpObj, NewDpPkgFileName, DpPkgFileName, RePackage):\r
        \r
        for PkgKey in DpObj.PackageSurfaceArea.keys():\r
            PkgGuid = PkgKey[0]\r
            PkgVersion = PkgKey[1]\r
            PkgInstallPath = PkgKey[2]\r
            self._AddPackage(PkgGuid, PkgVersion, DpObj.Header.GetGuid(), \\r
                             DpObj.Header.GetVersion(), PkgInstallPath)\r
            PkgObj = DpObj.PackageSurfaceArea[PkgKey]\r
            for ModKey in PkgObj.GetModuleDict().keys():\r
                ModGuid = ModKey[0]\r
                ModVersion = ModKey[1]\r
                ModInstallPath = ModKey[2]\r
                ModInstallPath = \\r
                os.path.normpath(os.path.join(PkgInstallPath, ModInstallPath))\r
                self._AddModuleInPackage(ModGuid, ModVersion, PkgGuid, \\r
                                         PkgVersion, ModInstallPath)\r
                ModObj = PkgObj.GetModuleDict()[ModKey]\r
                for Dep in ModObj.GetPackageDependencyList():\r
                    DepexGuid = Dep.GetGuid()\r
                    DepexVersion = Dep.GetVersion()\r
                    self._AddModuleDepex(ModGuid, ModVersion, ModInstallPath, \\r
                                         DepexGuid, DepexVersion)\r
            for (FilePath, Md5Sum) in PkgObj.FileList:\r
                self._AddDpFilePathList(DpObj.Header.GetGuid(), \\r
                                        DpObj.Header.GetVersion(), FilePath, \\r
                                        Md5Sum)\r
\r
        for ModKey in DpObj.ModuleSurfaceArea.keys():\r
            ModGuid = ModKey[0]\r
            ModVersion = ModKey[1]\r
            ModInstallPath = ModKey[2]\r
            self._AddStandaloneModule(ModGuid, ModVersion, \\r
                                      DpObj.Header.GetGuid(), \\r
                                      DpObj.Header.GetVersion(), \\r
                                      ModInstallPath)\r
            ModObj = DpObj.ModuleSurfaceArea[ModKey]\r
            for Dep in ModObj.GetPackageDependencyList():\r
                DepexGuid = Dep.GetGuid()\r
                DepexVersion = Dep.GetVersion()\r
                self._AddModuleDepex(ModGuid, ModVersion, ModInstallPath, \\r
                                     DepexGuid, DepexVersion)\r
            for (Path, Md5Sum) in ModObj.FileList:\r
                self._AddDpFilePathList(DpObj.Header.GetGuid(), \\r
                                        DpObj.Header.GetVersion(), \\r
                                        Path, Md5Sum)\r
\r
        #\r
        # add tool/misc files\r
        #\r
        for (Path, Md5Sum) in DpObj.FileList:\r
            self._AddDpFilePathList(DpObj.Header.GetGuid(), \\r
                                    DpObj.Header.GetVersion(), Path, Md5Sum)\r
                                \r
        self._AddDp(DpObj.Header.GetGuid(), DpObj.Header.GetVersion(), \\r
                    NewDpPkgFileName, DpPkgFileName, RePackage)\r
\r
        self.Conn.commit()\r
                    \r
    ## Add a distribution install information\r
    #\r
    # @param Guid         Guid of the distribution package  \r
    # @param Version      Version of the distribution package  \r
    # @param NewDpFileName the saved filename of distribution package file\r
    # @param DistributionFileName the filename of distribution package file\r
    #\r
    def _AddDp(self, Guid, Version, NewDpFileName, DistributionFileName, \\r
               RePackage):\r
        \r
        if Version == None or len(Version.strip()) == 0:\r
            Version = 'N/A'\r
        \r
        #\r
        # Add newly installed DP information to DB.\r
        #\r
        if NewDpFileName == None or len(NewDpFileName.strip()) == 0:\r
            PkgFileName = 'N/A'\r
        else:\r
            PkgFileName = NewDpFileName\r
        CurrentTime = time.time()\r
        SqlCommand = \\r
        """insert into %s values('%s', '%s', %s, '%s', '%s', '%s')""" % \\r
        (self.DpTable, Guid, Version, CurrentTime, PkgFileName, \\r
         DistributionFileName, str(RePackage).upper())\r
        self.Cur.execute(SqlCommand)\r
\r
        \r
    ## Add a file list from DP\r
    #\r
    # @param DpGuid: A DpGuid \r
    # @param DpVersion: A DpVersion\r
    # @param Path: A Path\r
    # @param Path: A Md5Sum\r
    #\r
    def _AddDpFilePathList(self, DpGuid, DpVersion, Path, Md5Sum):\r
        \r
        SqlCommand = """insert into %s values('%s', '%s', '%s', '%s')""" % \\r
        (self.DpFileListTable, Path, DpGuid, DpVersion, Md5Sum)\r
\r
        self.Cur.execute(SqlCommand)\r
            \r
    ## Add a package install information\r
    #\r
    # @param Guid: A package guid \r
    # @param Version: A package version\r
    # @param DpGuid: A DpGuid \r
    # @param DpVersion: A DpVersion\r
    # @param Path: A Path\r
    #\r
    def _AddPackage(self, Guid, Version, DpGuid=None, DpVersion=None, Path=''):\r
        \r
        if Version == None or len(Version.strip()) == 0:\r
            Version = 'N/A'\r
        \r
        if DpGuid == None or len(DpGuid.strip()) == 0:\r
            DpGuid = 'N/A'\r
        \r
        if DpVersion == None or len(DpVersion.strip()) == 0:\r
            DpVersion = 'N/A'\r
        \r
        #\r
        # Add newly installed package information to DB.\r
        #\r
        CurrentTime = time.time()\r
        SqlCommand = \\r
        """insert into %s values('%s', '%s', %s, '%s', '%s', '%s')""" % \\r
        (self.PkgTable, Guid, Version, CurrentTime, DpGuid, DpVersion, Path)\r
        self.Cur.execute(SqlCommand)\r
        \r
    ## Add a module that from a package install information\r
    #\r
    # @param Guid: A package guid \r
    # @param Version: A package version\r
    # @param PkgGuid: A package guid\r
    # @param PkgFileName: A package File Name\r
    #\r
    def _AddModuleInPackage(self, Guid, Version, PkgGuid=None, \\r
                            PkgVersion=None, Path=''):\r
        \r
        if Version == None or len(Version.strip()) == 0:\r
            Version = 'N/A'\r
        \r
        if PkgGuid == None or len(PkgGuid.strip()) == 0:\r
            PkgGuid = 'N/A'\r
        \r
        if PkgVersion == None or len(PkgVersion.strip()) == 0:\r
            PkgVersion = 'N/A'\r
        \r
        #\r
        # Add module from package information to DB.\r
        #\r
        CurrentTime = time.time()\r
        SqlCommand = \\r
        """insert into %s values('%s', '%s', %s, '%s', '%s', '%s')""" % \\r
        (self.ModInPkgTable, Guid, Version, CurrentTime, PkgGuid, PkgVersion, \\r
         Path)\r
        self.Cur.execute(SqlCommand)\r
    \r
    ## Add a module that is standalone install information\r
    #\r
    # @param Guid: a module Guid\r
    # @param Version: a module Version\r
    # @param DpGuid: a DpGuid\r
    # @param DpVersion: a DpVersion\r
    # @param Path: path\r
    #\r
    def _AddStandaloneModule(self, Guid, Version, DpGuid=None, \\r
                             DpVersion=None, Path=''):\r
        \r
        if Version == None or len(Version.strip()) == 0:\r
            Version = 'N/A'\r
        \r
        if DpGuid == None or len(DpGuid.strip()) == 0:\r
            DpGuid = 'N/A'\r
        \r
        if DpVersion == None or len(DpVersion.strip()) == 0:\r
            DpVersion = 'N/A'\r
        \r
        #\r
        # Add module standalone information to DB.\r
        #\r
        CurrentTime = time.time()\r
        SqlCommand = \\r
        """insert into %s values('%s', '%s', %s, '%s', '%s', '%s')""" % \\r
        (self.StandaloneModTable, Guid, Version, CurrentTime, DpGuid, \\r
         DpVersion, Path)\r
        self.Cur.execute(SqlCommand)\r
    \r
    ## Add a module depex\r
    #\r
    # @param Guid: a module Guid\r
    # @param Version: a module Version\r
    # @param DepexGuid: a module DepexGuid\r
    # @param DepexVersion: a module DepexVersion\r
    #\r
    def _AddModuleDepex(self, Guid, Version, Path, DepexGuid=None, \\r
                        DepexVersion=None):\r
                \r
        if DepexGuid == None or len(DepexGuid.strip()) == 0:\r
            DepexGuid = 'N/A'\r
        \r
        if DepexVersion == None or len(DepexVersion.strip()) == 0:\r
            DepexVersion = 'N/A'\r
        \r
        #\r
        # Add module depex information to DB.\r
        #\r
        SqlCommand = """insert into %s values('%s', '%s', '%s', '%s', '%s')"""\\r
         % (self.ModDepexTable, Guid, Version, Path, DepexGuid, DepexVersion)\r
        self.Cur.execute(SqlCommand)\r
        \r
    ## Remove a distribution install information, if no version specified, \r
    # remove all DPs with this Guid.\r
    #\r
    # @param DpGuid: guid of dpex \r
    # @param DpVersion: version of dpex\r
    #\r
    def RemoveDpObj(self, DpGuid, DpVersion):\r
        \r
        PkgList = self.GetPackageListFromDp(DpGuid, DpVersion)\r
        #\r
        # delete from ModDepex the standalone module's dependency\r
        #\r
        SqlCommand = \\r
        """delete from ModDepexInfo where ModDepexInfo.ModuleGuid in \r
        (select ModuleGuid from StandaloneModInfo as B where B.DpGuid = '%s' \r
        and B.DpVersion = '%s')\r
        and ModDepexInfo.ModuleVersion in\r
        (select ModuleVersion from StandaloneModInfo as B \r
        where B.DpGuid = '%s' and B.DpVersion = '%s')\r
        and ModDepexInfo.InstallPath in\r
        (select InstallPath from StandaloneModInfo as B \r
        where B.DpGuid = '%s' and B.DpVersion = '%s') """ % \\r
        (DpGuid, DpVersion, DpGuid, DpVersion, DpGuid, DpVersion)\r
\r
        self.Cur.execute(SqlCommand)\r
        #\r
        # delete from ModDepex the from pkg module's dependency\r
        #\r
        for Pkg in PkgList:\r
\r
            SqlCommand = \\r
            """delete from ModDepexInfo where ModDepexInfo.ModuleGuid in \r
            (select ModuleGuid from ModInPkgInfo \r
            where ModInPkgInfo.PackageGuid ='%s' and \r
            ModInPkgInfo.PackageVersion = '%s')\r
            and ModDepexInfo.ModuleVersion in\r
            (select ModuleVersion from ModInPkgInfo \r
            where ModInPkgInfo.PackageGuid ='%s' and \r
            ModInPkgInfo.PackageVersion = '%s')\r
            and ModDepexInfo.InstallPath in\r
            (select InstallPath from ModInPkgInfo where \r
            ModInPkgInfo.PackageGuid ='%s' \r
            and ModInPkgInfo.PackageVersion = '%s')""" \\r
                            % (Pkg[0], Pkg[1],Pkg[0], Pkg[1],Pkg[0], Pkg[1])\r
            \r
            self.Cur.execute(SqlCommand)\r
        #\r
        # delete the standalone module\r
        #\r
        SqlCommand = \\r
        """delete from %s where DpGuid ='%s' and DpVersion = '%s'""" % \\r
        (self.StandaloneModTable, DpGuid, DpVersion)\r
        self.Cur.execute(SqlCommand)\r
        #\r
        # delete the from pkg module\r
        #\r
        for Pkg in PkgList:\r
            SqlCommand = \\r
            """delete from %s where %s.PackageGuid ='%s' \r
            and %s.PackageVersion = '%s'""" % \\r
            (self.ModInPkgTable, self.ModInPkgTable, Pkg[0], \\r
             self.ModInPkgTable, Pkg[1])\r
            self.Cur.execute(SqlCommand)\r
        #\r
        # delete packages\r
        #\r
        SqlCommand = \\r
        """delete from %s where DpGuid ='%s' and DpVersion = '%s'""" % \\r
        (self.PkgTable, DpGuid, DpVersion)\r
        self.Cur.execute(SqlCommand)\r
        #\r
        # delete file list from DP\r
        #\r
        SqlCommand = \\r
        """delete from %s where DpGuid ='%s' and DpVersion = '%s'""" % \\r
        (self.DpFileListTable, DpGuid, DpVersion)\r
        self.Cur.execute(SqlCommand)\r
        #    \r
        # delete DP\r
        #\r
        SqlCommand = \\r
        """delete from %s where DpGuid ='%s' and DpVersion = '%s'""" % \\r
        (self.DpTable, DpGuid, DpVersion)\r
        self.Cur.execute(SqlCommand)\r
        \r
        self.Conn.commit()\r
        \r
    ## Get a list of distribution install information.\r
    #\r
    # @param Guid: distribution package guid  \r
    # @param Version: distribution package version \r
    #\r
    def GetDp(self, Guid, Version):\r
        \r
        if Version == None or len(Version.strip()) == 0:\r
            Version = 'N/A'\r
            Logger.Verbose(ST.MSG_GET_DP_INSTALL_LIST)\r
            (DpGuid, DpVersion) = (Guid, Version)\r
            SqlCommand = """select * from %s where DpGuid ='%s'""" % \\r
            (self.DpTable, DpGuid)\r
            self.Cur.execute(SqlCommand)\r
        \r
        else:\r
            Logger.Verbose(ST.MSG_GET_DP_INSTALL_INFO_START)\r
            (DpGuid, DpVersion) = (Guid, Version)\r
            SqlCommand = \\r
            """select * from %s where DpGuid ='%s' and DpVersion = '%s'""" % \\r
            (self.DpTable, DpGuid, DpVersion)\r
            self.Cur.execute(SqlCommand)\r
\r
        DpList = []\r
        for DpInfo in self.Cur:\r
            DpGuid = DpInfo[0]\r
            DpVersion = DpInfo[1]\r
            InstallTime = DpInfo[2]\r
            PkgFileName = DpInfo[3]\r
            DpList.append((DpGuid, DpVersion, InstallTime, PkgFileName))\r
            \r
        Logger.Verbose(ST.MSG_GET_DP_INSTALL_INFO_FINISH)    \r
        return DpList\r
    \r
    ## Get a list of distribution install dirs\r
    #\r
    # @param Guid: distribution package guid \r
    # @param Version: distribution package version \r
    #\r
    def GetDpInstallDirList(self, Guid, Version):\r
        SqlCommand = """select InstallPath from PkgInfo where DpGuid = '%s' and DpVersion = '%s'""" % (Guid, Version)\r
        self.Cur.execute(SqlCommand)\r
        DirList = []\r
        for Result in self.Cur:\r
            if Result[0] not in DirList:\r
                DirList.append(Result[0])\r
\r
        SqlCommand = """select InstallPath from StandaloneModInfo where DpGuid = '%s' and DpVersion = '%s'""" % \\r
                     (Guid, Version)\r
        self.Cur.execute(SqlCommand)\r
        for Result in self.Cur:\r
            if Result[0] not in DirList:\r
                DirList.append(Result[0])\r
\r
        return DirList\r
\r
\r
    ## Get a list of distribution install file path information.\r
    #\r
    # @param Guid: distribution package guid \r
    # @param Version: distribution package version \r
    #\r
    def GetDpFileList(self, Guid, Version):\r
        \r
        (DpGuid, DpVersion) = (Guid, Version)\r
        SqlCommand = \\r
        """select * from %s where DpGuid ='%s' and DpVersion = '%s'""" % \\r
        (self.DpFileListTable, DpGuid, DpVersion)\r
        self.Cur.execute(SqlCommand)\r
\r
        PathList = []\r
        for Result in self.Cur:\r
            Path = Result[0]\r
            Md5Sum = Result[3]\r
            PathList.append((Path, Md5Sum))\r
        \r
        return PathList\r
\r
    ## Get files' repackage attribute if present that are installed into current workspace\r
    #\r
    # @retval FileDict:  a Dict of file, key is file path, value is (DpGuid, DpVersion, NewDpFileName, RePackage)\r
    #\r
    def GetRePkgDict(self):\r
        SqlCommand = """select * from %s """ % (self.DpTable)\r
        self.Cur.execute(SqlCommand)\r
        \r
        DpInfoList = []\r
        for Result in self.Cur:\r
            DpInfoList.append(Result)\r
\r
        FileDict = {}        \r
        for Result in DpInfoList:\r
            DpGuid = Result[0]\r
            DpVersion = Result[1]\r
            NewDpFileName = Result[3]\r
            RePackage = Result[5]\r
            if RePackage == 'TRUE':\r
                RePackage = True\r
            else:\r
                RePackage = False\r
            for FileInfo in self.GetDpFileList(DpGuid, DpVersion):\r
                PathInfo = FileInfo[0]\r
                FileDict[PathInfo] = DpGuid, DpVersion, NewDpFileName, RePackage\r
                \r
        return FileDict\r
    \r
    ## Get (Guid, Version) from distribution file name information.\r
    #\r
    # @param DistributionFile: Distribution File  \r
    #\r
    def GetDpByName(self, DistributionFile):\r
        SqlCommand = """select * from %s where NewPkgFileName like '%s'""" % \\r
        (self.DpTable, '%' + DistributionFile)\r
        self.Cur.execute(SqlCommand)\r
\r
        for Result in self.Cur:\r
            DpGuid = Result[0]\r
            DpVersion = Result[1]\r
            NewDpFileName = Result[3]\r
   \r
            return (DpGuid, DpVersion, NewDpFileName)\r
        else:\r
            return (None, None, None)\r
        \r
    ## Get a list of package information.\r
    #\r
    # @param Guid: package guid  \r
    # @param Version: package version\r
    #\r
    def GetPackage(self, Guid, Version, DpGuid='', DpVersion=''):\r
        \r
        if DpVersion == '' or DpGuid == '':\r
\r
            (PackageGuid, PackageVersion) = (Guid, Version)\r
            SqlCommand = """select * from %s where PackageGuid ='%s' \r
            and PackageVersion = '%s'""" % (self.PkgTable, PackageGuid, \\r
                                            PackageVersion)\r
            self.Cur.execute(SqlCommand)\r
        \r
        elif Version == None or len(Version.strip()) == 0:\r
            \r
            SqlCommand = """select * from %s where PackageGuid ='%s'""" % \\r
            (self.PkgTable, Guid)\r
            self.Cur.execute(SqlCommand)\r
        else:\r
            (PackageGuid, PackageVersion) = (Guid, Version)\r
            SqlCommand = """select * from %s where PackageGuid ='%s' and \r
            PackageVersion = '%s'\r
                            and DpGuid = '%s' and DpVersion = '%s'""" % \\r
                            (self.PkgTable, PackageGuid, PackageVersion, \\r
                             DpGuid, DpVersion)\r
            self.Cur.execute(SqlCommand)\r
\r
        PkgList = []\r
        for PkgInfo in self.Cur:\r
            PkgGuid = PkgInfo[0]\r
            PkgVersion = PkgInfo[1]\r
            InstallTime = PkgInfo[2]\r
            InstallPath = PkgInfo[5]\r
            PkgList.append((PkgGuid, PkgVersion, InstallTime, DpGuid, \\r
                            DpVersion, InstallPath))\r
        \r
        return PkgList\r
 \r
       \r
    ## Get a list of module in package information.\r
    #\r
    # @param Guid: A module guid\r
    # @param Version: A module version\r
    #\r
    def GetModInPackage(self, Guid, Version, PkgGuid='', PkgVersion=''):\r
        \r
        if PkgVersion == '' or PkgGuid == '':\r
\r
            (ModuleGuid, ModuleVersion) = (Guid, Version)\r
            SqlCommand = """select * from %s where ModuleGuid ='%s' and \r
            ModuleVersion = '%s'""" % (self.ModInPkgTable, ModuleGuid, \\r
                                       ModuleVersion)\r
            self.Cur.execute(SqlCommand)\r
        \r
        else:\r
            (ModuleGuid, ModuleVersion) = (Guid, Version)\r
            SqlCommand = """select * from %s where ModuleGuid ='%s' and \r
            ModuleVersion = '%s' and PackageGuid ='%s' \r
            and PackageVersion = '%s'\r
                            """ % (self.ModInPkgTable, ModuleGuid, \\r
                                   ModuleVersion, PkgGuid, PkgVersion)\r
            self.Cur.execute(SqlCommand)\r
\r
        ModList = []\r
        for ModInfo in self.Cur:\r
            ModGuid = ModInfo[0]\r
            ModVersion = ModInfo[1]\r
            InstallTime = ModInfo[2]\r
            InstallPath = ModInfo[5]\r
            ModList.append((ModGuid, ModVersion, InstallTime, PkgGuid, \\r
                            PkgVersion, InstallPath))\r
        \r
        return ModList\r
    \r
    ## Get a list of module standalone.\r
    #\r
    # @param Guid: A module guid \r
    # @param Version: A module version \r
    #\r
    def GetStandaloneModule(self, Guid, Version, DpGuid='', DpVersion=''):\r
        \r
        if DpGuid == '':\r
            (ModuleGuid, ModuleVersion) = (Guid, Version)\r
            SqlCommand = """select * from %s where ModuleGuid ='%s' and \r
            ModuleVersion = '%s'""" % (self.StandaloneModTable, ModuleGuid, \\r
                                       ModuleVersion)\r
            self.Cur.execute(SqlCommand)\r
        \r
        else:\r
            (ModuleGuid, ModuleVersion) = (Guid, Version)\r
            SqlCommand = """select * from %s where ModuleGuid ='%s' and \r
            ModuleVersion = '%s' and DpGuid ='%s' and DpVersion = '%s'\r
                            """ % (self.StandaloneModTable, ModuleGuid, \\r
                                   ModuleVersion, DpGuid, DpVersion)\r
            self.Cur.execute(SqlCommand)\r
\r
        ModList = []\r
        for ModInfo in self.Cur:\r
            ModGuid = ModInfo[0]\r
            ModVersion = ModInfo[1]\r
            InstallTime = ModInfo[2]\r
            InstallPath = ModInfo[5]\r
            ModList.append((ModGuid, ModVersion, InstallTime, DpGuid, \\r
                            DpVersion, InstallPath))\r
        \r
        return ModList\r
    \r
    ## Get a list of module information that comes from DP.\r
    #\r
    # @param DpGuid: A Distrabution Guid \r
    # @param DpVersion: A Distrabution version  \r
    #\r
    def GetSModInsPathListFromDp(self, DpGuid, DpVersion):\r
\r
        PathList = []\r
        SqlCommand = """select InstallPath from %s where DpGuid ='%s' \r
        and DpVersion = '%s'\r
                        """ % (self.StandaloneModTable, DpGuid, DpVersion)\r
        self.Cur.execute(SqlCommand)\r
\r
        for Result in self.Cur:\r
            InstallPath = Result[0]\r
            PathList.append(InstallPath)\r
        \r
        return PathList\r
    \r
    ## Get a list of package information.\r
    #\r
    # @param DpGuid: A Distrabution Guid \r
    # @param DpVersion: A Distrabution version \r
    #\r
    def GetPackageListFromDp(self, DpGuid, DpVersion):\r
\r
        SqlCommand = """select * from %s where DpGuid ='%s' and \r
        DpVersion = '%s' """ % (self.PkgTable, DpGuid, DpVersion)\r
        self.Cur.execute(SqlCommand)\r
\r
        PkgList = []\r
        for PkgInfo in self.Cur:\r
            PkgGuid = PkgInfo[0]\r
            PkgVersion = PkgInfo[1]\r
            InstallPath = PkgInfo[5]\r
            PkgList.append((PkgGuid, PkgVersion, InstallPath))\r
        \r
        return PkgList\r
    \r
    ## Get a list of modules that depends on package information from a DP.\r
    #\r
    # @param DpGuid: A Distrabution Guid \r
    # @param DpVersion: A Distrabution version \r
    #\r
    def GetDpDependentModuleList(self, DpGuid, DpVersion):\r
        \r
        ModList = []\r
        PkgList = self.GetPackageListFromDp(DpGuid, DpVersion)\r
        if len(PkgList) > 0:\r
            return ModList\r
        \r
        for Pkg in PkgList:\r
            #\r
            # get all in-package modules that depends on current \r
            # Pkg (Guid match, Version match or NA) but not belong to \r
            # current Pkg\r
            #\r
            SqlCommand = """select t1.ModuleGuid, t1.ModuleVersion, \r
            t1.InstallPath from %s as t1, %s as t2 where \r
            t1.ModuleGuid = t2.ModuleGuid and \r
            t1.ModuleVersion = t2.ModuleVersion and t2.DepexGuid ='%s' \r
            and (t2.DepexVersion = '%s' or t2.DepexVersion = 'N/A') and\r
            t1.PackageGuid != '%s' and t1.PackageVersion != '%s'\r
                        """ % (self.ModInPkgTable, \\r
                               self.ModDepexTable, Pkg[0], Pkg[1], Pkg[0], \\r
                               Pkg[1])\r
            self.Cur.execute(SqlCommand)\r
            for ModInfo in self.Cur:\r
                ModGuid = ModInfo[0]\r
                ModVersion = ModInfo[1]\r
                InstallPath = ModInfo[2]\r
                ModList.append((ModGuid, ModVersion, InstallPath))\r
\r
            #\r
            # get all modules from standalone modules that depends on current \r
            #Pkg (Guid match, Version match or NA) but not in current dp\r
            #\r
            SqlCommand = \\r
            """select t1.ModuleGuid, t1.ModuleVersion, t1.InstallPath \r
            from %s as t1, %s as t2 where t1.ModuleGuid = t2.ModuleGuid and \r
            t1.ModuleVersion = t2.ModuleVersion and t2.DepexGuid ='%s' \r
            and (t2.DepexVersion = '%s' or t2.DepexVersion = 'N/A') and\r
                            t1.DpGuid != '%s' and t1.DpVersion != '%s'\r
                        """ % \\r
                        (self.StandaloneModTable, self.ModDepexTable, Pkg[0], \\r
                         Pkg[1], DpGuid, DpVersion)\r
            self.Cur.execute(SqlCommand)\r
            for ModInfo in self.Cur:\r
                ModGuid = ModInfo[0]\r
                ModVersion = ModInfo[1]\r
                InstallPath = ModInfo[2]\r
                ModList.append((ModGuid, ModVersion, InstallPath))\r
        \r
        \r
        return ModList\r
\r
    ## Get Dp's list of modules.\r
    #\r
    # @param DpGuid: A Distrabution Guid \r
    # @param DpVersion: A Distrabution version \r
    #\r
    def GetDpModuleList(self, DpGuid, DpVersion):      \r
        ModList = []\r
        #\r
        # get Dp module list from the DpFileList table\r
        #\r
        SqlCommand = """select FilePath \r
                        from %s\r
                        where DpGuid = '%s' and DpVersion = '%s' and \r
                        FilePath like '%%.inf'\r
                    """ % (self.DpFileListTable, DpGuid, DpVersion)\r
        self.Cur.execute(SqlCommand)\r
        for ModuleInfo in self.Cur:\r
            FilePath = ModuleInfo[0]\r
            ModList.append(FilePath)\r
            \r
        return ModList        \r
\r
        \r
    ## Get a module depex\r
    #\r
    # @param DpGuid: A module Guid \r
    # @param DpVersion: A module version \r
    # @param Path:\r
    #\r
    def GetModuleDepex(self, Guid, Version, Path):\r
                \r
        #\r
        # Get module depex information to DB.\r
        #\r
        SqlCommand = """select * from %s where ModuleGuid ='%s' and \r
        ModuleVersion = '%s' and InstallPath ='%s'\r
                            """ % (self.ModDepexTable, Guid, Version, Path)\r
        self.Cur.execute(SqlCommand)\r
        self.Conn.commit()\r
        \r
        DepexList = []\r
        for DepInfo in self.Cur:\r
            DepexGuid = DepInfo[3]\r
            DepexVersion = DepInfo[4]\r
            DepexList.append((DepexGuid, DepexVersion))\r
        \r
        return DepexList\r
    \r
    ## Close entire database\r
    #\r
    # Close the connection and cursor\r
    #\r
    def CloseDb(self):\r
        #\r
        # drop the dummy table\r
        #\r
        SqlCommand = """\r
        drop table IF EXISTS %s \r
        """ % self.DummyTable\r
        self.Cur.execute(SqlCommand)\r
        self.Conn.commit()\r
        \r
        self.Cur.close()\r
        self.Conn.close()\r
\r
    ## Convert To Sql String\r
    #\r
    # 1. Replace "'" with "''" in each item of StringList\r
    # \r
    # @param StringList:  A list for strings to be converted\r
    #\r
    def __ConvertToSqlString(self, StringList):\r
        if self.DpTable:\r
            pass\r
        return map(lambda s: s.replace("'", "''") , StringList)\r
\r
\r
\r