[mirror_edk2.git] / BaseTools / Source / Python / UPT / InstallPkg.py

## @file\r
# Install distribution package.\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
Install a distribution package\r
"""\r
##\r
# Import Modules\r
#\r
import os.path\r
from os import chmod\r
from os import SEEK_SET\r
from os import SEEK_END\r
import stat\r
import md5\r
from sys import stdin\r
from sys import platform\r
from shutil import rmtree\r
from shutil import copyfile\r
from traceback import format_exc\r
from platform import python_version\r
\r
from Logger import StringTable as ST\r
from Logger.ToolError import UNKNOWN_ERROR\r
from Logger.ToolError import FILE_UNKNOWN_ERROR\r
from Logger.ToolError import OPTION_MISSING\r
from Logger.ToolError import UPT_ALREADY_INSTALLED_ERROR\r
from Logger.ToolError import FatalError\r
from Logger.ToolError import ABORT_ERROR\r
from Logger.ToolError import CODE_ERROR\r
from Logger.ToolError import FORMAT_INVALID\r
from Logger.ToolError import FILE_TYPE_MISMATCH\r
import Logger.Log as Logger\r
\r
from Library.Misc import CheckEnvVariable\r
from Library.Misc import Sdict\r
from Library.Misc import ConvertPath\r
from Library.ParserValidate import IsValidInstallPath\r
from Xml.XmlParser import DistributionPackageXml\r
from GenMetaFile.GenDecFile import PackageToDec\r
from GenMetaFile.GenInfFile import ModuleToInf\r
from Core.PackageFile import PackageFile\r
from Core.PackageFile import FILE_NOT_FOUND\r
from Core.PackageFile import FILE_CHECKSUM_FAILURE\r
from Core.PackageFile import CreateDirectory\r
from Core.DependencyRules import DependencyRules\r
from Library import GlobalData\r
\r
## InstallNewPackage\r
#\r
# @param WorkspaceDir:   Workspace Directory\r
# @param Path:           Package Path\r
# @param CustomPath:     whether need to customize path at first\r
#\r
def InstallNewPackage(WorkspaceDir, Path, CustomPath = False):\r
    if os.path.isabs(Path):\r
        Logger.Info(ST.MSG_RELATIVE_PATH_ONLY%Path)\r
    elif CustomPath:\r
        Logger.Info(ST.MSG_NEW_PKG_PATH)\r
    else:\r
        Path = ConvertPath(Path)\r
        Path = os.path.normpath(Path)\r
        FullPath = os.path.normpath(os.path.join(WorkspaceDir, Path))\r
        if os.path.exists(FullPath):\r
            Logger.Info(ST.ERR_DIR_ALREADY_EXIST%FullPath)\r
        else:\r
            return Path\r
\r
    Input = stdin.readline()\r
    Input = Input.replace('\r', '').replace('\n', '')\r
    if Input == '':\r
        Logger.Error("InstallPkg", UNKNOWN_ERROR, ST.ERR_USER_INTERRUPT)\r
    Input = Input.replace('\r', '').replace('\n', '')\r
    return InstallNewPackage(WorkspaceDir, Input, False)\r
\r
\r
## InstallNewModule\r
#\r
# @param WorkspaceDir:   Workspace Directory\r
# @param Path:           Standalone Module Path\r
# @param PathList:       The already installed standalone module Path list\r
#\r
def InstallNewModule(WorkspaceDir, Path, PathList = None):\r
    if PathList == None:\r
        PathList = []\r
    Path = ConvertPath(Path)\r
    Path = os.path.normpath(Path)\r
    FullPath = os.path.normpath(os.path.join(WorkspaceDir, Path))\r
    if os.path.exists(FullPath) and FullPath not in PathList:\r
        Logger.Info(ST.ERR_DIR_ALREADY_EXIST%Path)\r
    elif Path == FullPath:\r
        Logger.Info(ST.MSG_RELATIVE_PATH_ONLY%FullPath)\r
    else:\r
        return Path\r
    \r
    Input = stdin.readline()\r
    Input = Input.replace('\r', '').replace('\n', '')\r
    if Input == '':\r
        Logger.Error("InstallPkg", UNKNOWN_ERROR, ST.ERR_USER_INTERRUPT)\r
    Input = Input.replace('\r', '').replace('\n', '')\r
    return InstallNewModule(WorkspaceDir, Input, PathList)\r
\r
    \r
## InstallNewFile\r
#\r
# @param WorkspaceDir:   Workspace Direction\r
# @param File:      File\r
#\r
def InstallNewFile(WorkspaceDir, File):\r
    FullPath = os.path.normpath(os.path.join(WorkspaceDir, File))\r
    if os.path.exists(FullPath):\r
        Logger.Info(ST.ERR_FILE_ALREADY_EXIST %File)\r
        Input = stdin.readline()\r
        Input = Input.replace('\r', '').replace('\n', '')\r
        if Input == '':\r
            Logger.Error("InstallPkg", UNKNOWN_ERROR, ST.ERR_USER_INTERRUPT)\r
        Input = Input.replace('\r', '').replace('\n', '')\r
        return InstallNewFile(WorkspaceDir, Input)\r
    else:\r
        return File\r
\r
## UnZipDp\r
#\r
# UnZipDp\r
#\r
def UnZipDp(WorkspaceDir, Options, DataBase):\r
    ContentZipFile = None\r
    Logger.Quiet(ST.MSG_UZIP_PARSE_XML)\r
    DpPkgFileName = Options.PackageFile\r
    DistFile = PackageFile(DpPkgFileName)\r
    \r
    DpDescFileName, ContentFileName = GetDPFile(DistFile.GetZipFile())\r
    \r
    GlobalData.gUNPACK_DIR = os.path.normpath(os.path.join(WorkspaceDir, ".tmp"))\r
    DistPkgFile = DistFile.UnpackFile(DpDescFileName,\r
        os.path.normpath(os.path.join(GlobalData.gUNPACK_DIR, DpDescFileName)))\r
    if not DistPkgFile:\r
        Logger.Error("InstallPkg", FILE_NOT_FOUND, ST.ERR_FILE_BROKEN %DpDescFileName)\r
    \r
    #\r
    # Generate distpkg\r
    #\r
    DistPkgObj = DistributionPackageXml()\r
    DistPkg = DistPkgObj.FromXml(DistPkgFile)\r
    if DistPkg.Header.RePackage == '':\r
        DistPkg.Header.RePackage = False\r
    if DistPkg.Header.ReadOnly == '':\r
        DistPkg.Header.ReadOnly = False\r
    \r
    #\r
    # prepare check dependency\r
    #\r
    Dep = DependencyRules(DataBase)\r
    #\r
    # Check distribution package installed or not\r
    #\r
    if Dep.CheckDpExists(DistPkg.Header.GetGuid(),\r
        DistPkg.Header.GetVersion()):\r
        Logger.Error("InstallPkg", UPT_ALREADY_INSTALLED_ERROR,\r
            ST.WRN_DIST_PKG_INSTALLED)\r
    #\r
    # Check distribution dependency (all module dependency should be\r
    # satisfied)\r
    #\r
    if not Dep.CheckDpDepexSatisfied(DistPkg):\r
        Logger.Error("InstallPkg", UNKNOWN_ERROR,\r
            ST.ERR_PACKAGE_NOT_MATCH_DEPENDENCY,\r
            ExtraData=DistPkg.Header.Name)\r
    #\r
    # unzip contents.zip file\r
    #\r
    ContentFile = DistFile.UnpackFile(ContentFileName,\r
        os.path.normpath(os.path.join(GlobalData.gUNPACK_DIR, ContentFileName)))\r
    if not ContentFile:\r
        Logger.Error("InstallPkg", FILE_NOT_FOUND,\r
            ST.ERR_FILE_BROKEN % ContentFileName)\r
\r
    FilePointer = open(ContentFile, "rb")\r
    #\r
    # Assume no archive comment.\r
    #\r
    FilePointer.seek(0, SEEK_SET)\r
    FilePointer.seek(0, SEEK_END)\r
    #\r
    # Get file size\r
    #                \r
    FileSize = FilePointer.tell()\r
    FilePointer.close()\r
               \r
    if FileSize != 0:        \r
        ContentZipFile = PackageFile(ContentFile)\r
\r
    #\r
    # verify MD5 signature when existed\r
    #\r
    if DistPkg.Header.Signature != '':\r
        Md5Sigature = md5.new(open(ContentFile, 'rb').read())\r
        if DistPkg.Header.Signature != Md5Sigature.hexdigest():\r
            ContentZipFile.Close()\r
            Logger.Error("InstallPkg", FILE_CHECKSUM_FAILURE,\r
                ExtraData=ContentFile)\r
\r
    return DistPkg, Dep, ContentZipFile, DpPkgFileName\r
\r
## GetPackageList\r
#\r
# GetPackageList\r
#\r
def GetPackageList(DistPkg, Dep, WorkspaceDir, Options, ContentZipFile, ModuleList, PackageList):\r
    NewDict = Sdict()\r
    for Guid, Version, Path in DistPkg.PackageSurfaceArea:\r
        PackagePath = Path\r
        Package = DistPkg.PackageSurfaceArea[Guid, Version, Path]\r
        Logger.Info(ST.MSG_INSTALL_PACKAGE % Package.GetName())\r
        if Dep.CheckPackageExists(Guid, Version):\r
            Logger.Info(ST.WRN_PACKAGE_EXISTED %(Guid, Version))\r
        NewPackagePath = InstallNewPackage(WorkspaceDir, PackagePath, Options.CustomPath)\r
        InstallPackageContent(PackagePath, NewPackagePath, Package, ContentZipFile, Dep, WorkspaceDir, ModuleList, \r
                              DistPkg.Header.ReadOnly)\r
        PackageList.append(Package)\r
        \r
        NewDict[Guid, Version, Package.GetPackagePath()] = Package\r
    \r
    #\r
    # Now generate meta-data files, first generate all dec for package\r
    # dec should be generated before inf, and inf should be generated after\r
    # all packages installed, else hard to resolve modules' package\r
    # dependency (Hard to get the location of the newly installed package)\r
    #\r
    for Package in PackageList:\r
        FilePath = PackageToDec(Package)\r
        Md5Sigature = md5.new(open(str(FilePath), 'rb').read())\r
        Md5Sum = Md5Sigature.hexdigest()\r
        if (FilePath, Md5Sum) not in Package.FileList:\r
            Package.FileList.append((FilePath, Md5Sum))\r
    \r
    return NewDict\r
\r
## GetModuleList\r
#\r
# GetModuleList\r
#\r
def GetModuleList(DistPkg, Dep, WorkspaceDir, ContentZipFile, ModuleList):\r
    #\r
    # ModulePathList will keep track of the standalone module path that\r
    # we just installed. If a new module's path in that list \r
    # (only multiple INF in one directory will be so), we will \r
    # install them directly. If not, we will try to create a new directory \r
    # for it.\r
    #\r
    ModulePathList = []   \r
    \r
    #\r
    # Check module exist and install\r
    #\r
    Module = None\r
    NewDict = Sdict()        \r
    for Guid, Version, Name, Path in DistPkg.ModuleSurfaceArea:\r
        ModulePath = Path\r
        Module = DistPkg.ModuleSurfaceArea[Guid, Version, Name, Path]\r
        Logger.Info(ST.MSG_INSTALL_MODULE % Module.GetName())\r
        if Dep.CheckModuleExists(Guid, Version, Name, Path):\r
            Logger.Quiet(ST.WRN_MODULE_EXISTED %Path)\r
        #\r
        # here check for the multiple inf share the same module path cases:\r
        # they should be installed into the same directory\r
        #\r
        ModuleFullPath = \\r
        os.path.normpath(os.path.join(WorkspaceDir, ModulePath))\r
        if ModuleFullPath not in ModulePathList:\r
            NewModulePath = InstallNewModule(WorkspaceDir, ModulePath, ModulePathList)\r
            NewModuleFullPath = os.path.normpath(os.path.join(WorkspaceDir, NewModulePath))\r
            ModulePathList.append(NewModuleFullPath)\r
        else:\r
            NewModulePath = ModulePath\r
        \r
        InstallModuleContent(ModulePath, NewModulePath, '', Module, ContentZipFile, WorkspaceDir, ModuleList, None, \r
                             DistPkg.Header.ReadOnly)\r
        #\r
        # Update module\r
        #\r
        Module.SetModulePath(Module.GetModulePath().replace(Path, NewModulePath, 1))\r
        \r
        NewDict[Guid, Version, Name, Module.GetModulePath()] = Module\r
\r
    #\r
    # generate all inf for modules\r
    #\r
    for (Module, Package) in ModuleList:\r
        FilePath = ModuleToInf(Module)\r
        Md5Sigature = md5.new(open(str(FilePath), 'rb').read())\r
        Md5Sum = Md5Sigature.hexdigest()\r
        if Package:\r
            if (FilePath, Md5Sum) not in Package.FileList:\r
                Package.FileList.append((FilePath, Md5Sum))\r
        else:\r
            if (FilePath, Md5Sum) not in Module.FileList:\r
                Module.FileList.append((FilePath, Md5Sum))\r
    \r
    return NewDict\r
\r
## GenToolMisc\r
#\r
# GenToolMisc\r
#\r
#\r
def GenToolMisc(DistPkg, WorkspaceDir, ContentZipFile):\r
    ToolObject = DistPkg.Tools\r
    MiscObject = DistPkg.MiscellaneousFiles\r
    DistPkg.FileList = []\r
    FileList = []\r
    ToolFileNum = 0\r
    FileNum = 0\r
    RootDir = WorkspaceDir\r
    \r
    #\r
    # FileList stores both tools files and misc files\r
    # Misc file list must be appended to FileList *AFTER* Tools file list\r
    #\r
    if ToolObject:\r
        FileList += ToolObject.GetFileList()\r
        ToolFileNum = len(ToolObject.GetFileList())\r
        if 'EDK_TOOLS_PATH' in os.environ:\r
            RootDir = os.environ['EDK_TOOLS_PATH']\r
    if MiscObject:\r
        FileList += MiscObject.GetFileList()\r
    for FileObject in FileList:\r
        FileNum += 1\r
        if FileNum > ToolFileNum:\r
            #\r
            # Misc files, root should be changed to WORKSPACE\r
            #\r
            RootDir = WorkspaceDir\r
        File = ConvertPath(FileObject.GetURI())\r
        ToFile = os.path.normpath(os.path.join(RootDir, File))\r
        if os.path.exists(ToFile):\r
            Logger.Info( ST.WRN_FILE_EXISTED % ToFile )\r
            #\r
            # ask for user input the new file name\r
            #\r
            Logger.Info( ST.MSG_NEW_FILE_NAME)\r
            Input = stdin.readline()\r
            Input = Input.replace('\r', '').replace('\n', '')\r
            OrigPath = os.path.split(ToFile)[0]\r
            ToFile = os.path.normpath(os.path.join(OrigPath, Input))\r
        FromFile = os.path.join(FileObject.GetURI())\r
        Md5Sum = InstallFile(ContentZipFile, FromFile, ToFile, DistPkg.Header.ReadOnly, FileObject.GetExecutable())\r
        DistPkg.FileList.append((ToFile, Md5Sum))\r
\r
## Tool entrance method\r
#\r
# This method mainly dispatch specific methods per the command line options.\r
# If no error found, return zero value so the caller of this tool can know\r
# if it's executed successfully or not.\r
#\r
# @param  Options: command Options\r
#\r
def Main(Options = None):\r
    ContentZipFile, DistFile = None, None\r
\r
    try:\r
        DataBase = GlobalData.gDB        \r
        CheckEnvVariable()\r
        WorkspaceDir = GlobalData.gWORKSPACE\r
        if not Options.PackageFile:\r
            Logger.Error("InstallPkg", OPTION_MISSING, ExtraData=ST.ERR_SPECIFY_PACKAGE)\r
        \r
        #\r
        # unzip dist.pkg file\r
        #\r
        DistPkg, Dep, ContentZipFile, DpPkgFileName = UnZipDp(WorkspaceDir, Options, DataBase)\r
\r
        #\r
        # PackageList, ModuleList record the information for the meta-data\r
        # files that need to be generated later\r
        #\r
        PackageList = []\r
        ModuleList = []\r
        DistPkg.PackageSurfaceArea = GetPackageList(DistPkg, Dep, WorkspaceDir, Options, \r
                                                    ContentZipFile, ModuleList, PackageList)\r
\r
        DistPkg.ModuleSurfaceArea = GetModuleList(DistPkg, Dep, WorkspaceDir, ContentZipFile, ModuleList)       \r
        \r
        \r
        GenToolMisc(DistPkg, WorkspaceDir, ContentZipFile)\r
        \r
        #\r
        # copy "Distribution File" to directory $(WORKSPACE)/conf/upt\r
        #\r
        DistFileName = os.path.split(DpPkgFileName)[1]\r
        DestDir = os.path.normpath(os.path.join(WorkspaceDir, GlobalData.gUPT_DIR))\r
        CreateDirectory(DestDir)\r
        DestFile = os.path.normpath(os.path.join(DestDir, DistFileName))\r
        if os.path.exists(DestFile):\r
            FileName, Ext = os.path.splitext(DistFileName)\r
            NewFileName = FileName + '_' + DistPkg.Header.GetGuid() + '_' + DistPkg.Header.GetVersion() + Ext\r
            DestFile = os.path.normpath(os.path.join(DestDir, NewFileName))\r
            if os.path.exists(DestFile):\r
                #\r
                # ask for user input the new file name\r
                #\r
                Logger.Info( ST.MSG_NEW_FILE_NAME_FOR_DIST)\r
                Input = stdin.readline()\r
                Input = Input.replace('\r', '').replace('\n', '')\r
                DestFile = os.path.normpath(os.path.join(DestDir, Input))\r
        copyfile(DpPkgFileName, DestFile)\r
        NewDpPkgFileName = DestFile[DestFile.find(DestDir) + len(DestDir) + 1:]\r
\r
        #\r
        # update database\r
        #\r
        Logger.Quiet(ST.MSG_UPDATE_PACKAGE_DATABASE)\r
        DataBase.AddDPObject(DistPkg, NewDpPkgFileName, DistFileName, \r
                       DistPkg.Header.RePackage)\r
        \r
        ReturnCode = 0\r
        \r
    except FatalError, XExcept:\r
        ReturnCode = XExcept.args[0]\r
        if Logger.GetLevel() <= Logger.DEBUG_9:\r
            Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
                platform) + format_exc())\r
    except KeyboardInterrupt:\r
        ReturnCode = ABORT_ERROR\r
        if Logger.GetLevel() <= Logger.DEBUG_9:\r
            Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
                platform) + format_exc())\r
    except:\r
        ReturnCode = CODE_ERROR\r
        Logger.Error(\r
                    "\nInstallPkg",\r
                    CODE_ERROR,\r
                    ST.ERR_UNKNOWN_FATAL_INSTALL_ERR % Options.PackageFile,\r
                    ExtraData=ST.MSG_SEARCH_FOR_HELP,\r
                    RaiseError=False\r
                    )\r
        Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
            platform) + format_exc())\r
\r
    finally:\r
        Logger.Quiet(ST.MSG_REMOVE_TEMP_FILE_STARTED)\r
        if DistFile:\r
            DistFile.Close()\r
        if ContentZipFile:\r
            ContentZipFile.Close()\r
        if GlobalData.gUNPACK_DIR:\r
            rmtree(GlobalData.gUNPACK_DIR)\r
            GlobalData.gUNPACK_DIR = None\r
        Logger.Quiet(ST.MSG_REMOVE_TEMP_FILE_DONE)\r
\r
    if ReturnCode == 0:\r
        Logger.Quiet(ST.MSG_FINISH)\r
    \r
    return ReturnCode\r
\r
## InstallModuleContent method\r
#\r
# If this is standalone module, then Package should be none,\r
# ModulePath should be ''\r
#   @param  FromPath: FromPath\r
#   @param  NewPath: NewPath\r
#   @param  ModulePath: ModulePath\r
#   @param  Module: Module\r
#   @param  ContentZipFile: ContentZipFile\r
#   @param  WorkspaceDir: WorkspaceDir\r
#   @param  ModuleList: ModuleList\r
#   @param  Package: Package\r
#\r
def InstallModuleContent(FromPath, NewPath, ModulePath, Module, ContentZipFile,\r
    WorkspaceDir, ModuleList, Package = None, ReadOnly = False):\r
    \r
    if NewPath.startswith("\\") or NewPath.startswith("/"):\r
        NewPath = NewPath[1:]\r
    \r
    if not IsValidInstallPath(NewPath):\r
        Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%NewPath) \r
           \r
    NewModuleFullPath = os.path.normpath(os.path.join(WorkspaceDir, NewPath,\r
        ConvertPath(ModulePath)))\r
    Module.SetFullPath(os.path.normpath(os.path.join(NewModuleFullPath,\r
        ConvertPath(Module.GetName()) + '.inf')))\r
    Module.FileList = []\r
    \r
    for MiscFile in Module.GetMiscFileList():\r
        if not MiscFile:\r
            continue\r
        for Item in MiscFile.GetFileList():\r
            File = Item.GetURI()\r
            if File.startswith("\\") or File.startswith("/"):\r
                File = File[1:]\r
            \r
            if not IsValidInstallPath(File):\r
                Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%File)\r
                      \r
            FromFile = os.path.join(FromPath, ModulePath, File)\r
            Executable = Item.GetExecutable()            \r
            ToFile = os.path.normpath(os.path.join(NewModuleFullPath, ConvertPath(File)))\r
            Md5Sum = InstallFile(ContentZipFile, FromFile, ToFile, ReadOnly, Executable)\r
            if Package and ((ToFile, Md5Sum) not in Package.FileList):\r
                Package.FileList.append((ToFile, Md5Sum))\r
            elif Package:\r
                continue\r
            elif (ToFile, Md5Sum) not in Module.FileList:\r
                Module.FileList.append((ToFile, Md5Sum))\r
    for Item in Module.GetSourceFileList():\r
        File = Item.GetSourceFile()\r
        if File.startswith("\\") or File.startswith("/"):\r
            File = File[1:]\r
            \r
        if not IsValidInstallPath(File):\r
            Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%File) \r
                               \r
        FromFile = os.path.join(FromPath, ModulePath, File)\r
        ToFile = os.path.normpath(os.path.join(NewModuleFullPath, ConvertPath(File)))\r
        Md5Sum = InstallFile(ContentZipFile, FromFile, ToFile, ReadOnly)\r
        if Package and ((ToFile, Md5Sum) not in Package.FileList):\r
            Package.FileList.append((ToFile, Md5Sum))\r
        elif Package:\r
            continue\r
        elif (ToFile, Md5Sum) not in Module.FileList:\r
            Module.FileList.append((ToFile, Md5Sum))\r
    for Item in Module.GetBinaryFileList():\r
        FileNameList = Item.GetFileNameList()\r
        for FileName in FileNameList:              \r
            File = FileName.GetFilename()          \r
            if File.startswith("\\") or File.startswith("/"):\r
                File = File[1:]\r
                \r
            if not IsValidInstallPath(File):\r
                Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%File)\r
\r
            FromFile = os.path.join(FromPath, ModulePath, File)\r
            ToFile = os.path.normpath(os.path.join(NewModuleFullPath, ConvertPath(File)))\r
            Md5Sum = InstallFile(ContentZipFile, FromFile, ToFile, ReadOnly)       \r
            if Package and ((ToFile, Md5Sum) not in Package.FileList):\r
                Package.FileList.append((ToFile, Md5Sum))\r
            elif Package:\r
                continue\r
            elif (ToFile, Md5Sum) not in Module.FileList:\r
                Module.FileList.append((ToFile, Md5Sum))\r
    \r
    InstallModuleContentZipFile(ContentZipFile, FromPath, ModulePath, WorkspaceDir, NewPath, Module, Package, ReadOnly,\r
                                ModuleList)\r
\r
## InstallModuleContentZipFile\r
#\r
# InstallModuleContentZipFile\r
#\r
def InstallModuleContentZipFile(ContentZipFile, FromPath, ModulePath, WorkspaceDir, NewPath, Module, Package, ReadOnly,\r
                                ModuleList):\r
    #\r
    # Extract other files under current module path in content Zip file but not listed in the description \r
    #\r
    if ContentZipFile:\r
        for FileName in ContentZipFile.GetZipFile().namelist():\r
            FileName = os.path.normpath(FileName)\r
            CheckPath = os.path.normpath(os.path.join(FromPath, ModulePath))\r
            if FileUnderPath(FileName, CheckPath):\r
                if FileName.startswith("\\") or FileName.startswith("/"):\r
                    FileName = FileName[1:]\r
                    \r
                if not IsValidInstallPath(FileName):\r
                    Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%FileName)\r
                                                   \r
                FromFile = FileName\r
                ToFile = os.path.normpath(os.path.join(WorkspaceDir, \r
                        ConvertPath(FileName.replace(FromPath, NewPath, 1))))\r
                CheckList = Module.FileList\r
                if Package:\r
                    CheckList += Package.FileList\r
                for Item in CheckList:\r
                    if Item[0] == ToFile:\r
                        break\r
                else:\r
                    Md5Sum = InstallFile(ContentZipFile, FromFile, ToFile, ReadOnly)\r
                    if Package and ((ToFile, Md5Sum) not in Package.FileList):\r
                        Package.FileList.append((ToFile, Md5Sum))\r
                    elif Package:\r
                        continue\r
                    elif (ToFile, Md5Sum) not in Module.FileList:\r
                        Module.FileList.append((ToFile, Md5Sum))            \r
    \r
    ModuleList.append((Module, Package))\r
\r
## FileUnderPath\r
#  Check whether FileName started with directory specified by CheckPath \r
#\r
# @param FileName: the FileName need to be checked\r
# @param CheckPath: the path need to be checked against\r
# @return:  True or False  \r
#\r
def FileUnderPath(FileName, CheckPath):\r
    FileName = FileName.replace('\\', '/')\r
    FileName = os.path.normpath(FileName)\r
    CheckPath = CheckPath.replace('\\', '/')\r
    CheckPath = os.path.normpath(CheckPath)\r
    if FileName.startswith(CheckPath):\r
        RemainingPath = os.path.normpath(FileName.replace(CheckPath, '', 1))\r
        while RemainingPath.startswith('\\') or RemainingPath.startswith('/'):\r
            RemainingPath = RemainingPath[1:]\r
        if FileName == os.path.normpath(os.path.join(CheckPath, RemainingPath)):\r
            return True\r
    \r
    return False\r
\r
## InstallFile\r
#  Extract File from Zipfile, set file attribute, and return the Md5Sum\r
#\r
# @return:  True or False  \r
#\r
def InstallFile(ContentZipFile, FromFile, ToFile, ReadOnly, Executable=False):\r
    if not ContentZipFile or not ContentZipFile.UnpackFile(FromFile, ToFile):\r
        Logger.Error("UPT", FILE_NOT_FOUND, ST.ERR_INSTALL_FILE_FROM_EMPTY_CONTENT%FromFile)\r
\r
    if ReadOnly:\r
        if not Executable:\r
            chmod(ToFile, stat.S_IREAD)\r
        else:\r
            chmod(ToFile, stat.S_IREAD|stat.S_IEXEC)\r
    elif Executable:\r
        chmod(ToFile, stat.S_IREAD|stat.S_IWRITE|stat.S_IEXEC)\r
    else:\r
        chmod(ToFile, stat.S_IREAD|stat.S_IWRITE)\r
                \r
    Md5Sigature = md5.new(open(str(ToFile), 'rb').read())\r
    Md5Sum = Md5Sigature.hexdigest()\r
    return Md5Sum\r
        \r
## InstallPackageContent method\r
#\r
#   @param  FromPath: FromPath\r
#   @param  ToPath: ToPath\r
#   @param  Package: Package\r
#   @param  ContentZipFile: ContentZipFile\r
#   @param  Dep: Dep\r
#   @param  WorkspaceDir: WorkspaceDir\r
#   @param  ModuleList: ModuleList\r
#\r
def InstallPackageContent(FromPath, ToPath, Package, ContentZipFile, Dep,\r
    WorkspaceDir, ModuleList, ReadOnly = False):\r
    if Dep:\r
        pass\r
    Package.FileList = []\r
    \r
    if ToPath.startswith("\\") or ToPath.startswith("/"):\r
        ToPath = ToPath[1:]\r
    \r
    if not IsValidInstallPath(ToPath):\r
        Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%ToPath)     \r
\r
    if FromPath.startswith("\\") or FromPath.startswith("/"):\r
        FromPath = FromPath[1:]\r
    \r
    if not IsValidInstallPath(FromPath):\r
        Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%FromPath)   \r
    \r
    PackageFullPath = os.path.normpath(os.path.join(WorkspaceDir, ToPath))\r
    for MiscFile in Package.GetMiscFileList():\r
        for Item in MiscFile.GetFileList():\r
            FileName = Item.GetURI()\r
            if FileName.startswith("\\") or FileName.startswith("/"):\r
                FileName = FileName[1:]\r
                \r
            if not IsValidInstallPath(FileName):\r
                Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%FileName)\r
                            \r
            FromFile = os.path.join(FromPath, FileName)\r
            Executable = Item.GetExecutable()\r
            ToFile =  (os.path.join(PackageFullPath, ConvertPath(FileName)))\r
            Md5Sum = InstallFile(ContentZipFile, FromFile, ToFile, ReadOnly, Executable)\r
            if (ToFile, Md5Sum) not in Package.FileList:\r
                Package.FileList.append((ToFile, Md5Sum))\r
    PackageIncludeArchList = [] \r
    for Item in Package.GetPackageIncludeFileList():\r
        FileName = Item.GetFilePath()\r
        if FileName.startswith("\\") or FileName.startswith("/"):\r
            FileName = FileName[1:]\r
            \r
        if not IsValidInstallPath(FileName):\r
            Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%FileName) \r
                   \r
        FromFile = os.path.join(FromPath, FileName)\r
        ToFile = os.path.normpath(os.path.join(PackageFullPath, ConvertPath(FileName)))\r
        RetFile = ContentZipFile.UnpackFile(FromFile, ToFile)\r
        if RetFile == '':\r
            #\r
            # a non-exist path in Zipfile will return '', which means an include directory in our case\r
            # save the information for later DEC creation usage and also create the directory\r
            #\r
            PackageIncludeArchList.append([Item.GetFilePath(), Item.GetSupArchList()])\r
            CreateDirectory(ToFile)\r
            continue\r
        if ReadOnly:\r
            chmod(ToFile, stat.S_IREAD)\r
        else:\r
            chmod(ToFile, stat.S_IREAD|stat.S_IWRITE)            \r
        Md5Sigature = md5.new(open(str(ToFile), 'rb').read())\r
        Md5Sum = Md5Sigature.hexdigest()\r
        if (ToFile, Md5Sum) not in Package.FileList:\r
            Package.FileList.append((ToFile, Md5Sum))\r
    Package.SetIncludeArchList(PackageIncludeArchList)\r
    \r
    for Item in Package.GetStandardIncludeFileList():\r
        FileName = Item.GetFilePath()\r
        if FileName.startswith("\\") or FileName.startswith("/"):\r
            FileName = FileName[1:]\r
            \r
        if not IsValidInstallPath(FileName):\r
            Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%FileName) \r
                    \r
        FromFile = os.path.join(FromPath, FileName)\r
        ToFile = os.path.normpath(os.path.join(PackageFullPath, ConvertPath(FileName)))\r
        Md5Sum = InstallFile(ContentZipFile, FromFile, ToFile, ReadOnly)\r
        if (ToFile, Md5Sum) not in Package.FileList:\r
            Package.FileList.append((ToFile, Md5Sum))\r
\r
    #\r
    # Update package\r
    #\r
    Package.SetPackagePath(Package.GetPackagePath().replace(FromPath,\r
        ToPath, 1))\r
    Package.SetFullPath(os.path.normpath(os.path.join(PackageFullPath,\r
        ConvertPath(Package.GetName()) + '.dec')))\r
\r
    #\r
    # Install files in module\r
    #\r
    Module = None\r
    ModuleDict = Package.GetModuleDict()\r
    for ModuleGuid, ModuleVersion, ModuleName, ModulePath in ModuleDict:\r
        Module = ModuleDict[ModuleGuid, ModuleVersion, ModuleName, ModulePath]\r
        InstallModuleContent(FromPath, ToPath, ModulePath, Module,\r
            ContentZipFile, WorkspaceDir, ModuleList, Package, ReadOnly)\r
\r
## GetDPFile method\r
#\r
#   @param  ZipFile: A ZipFile\r
#\r
def GetDPFile(ZipFile):\r
    ContentFile = ''\r
    DescFile = ''\r
    for FileName in ZipFile.namelist():\r
        if FileName.endswith('.content'):\r
            if not ContentFile:\r
                ContentFile = FileName\r
                continue\r
        elif FileName.endswith('.pkg'):\r
            if not DescFile:\r
                DescFile = FileName\r
                continue\r
        else:\r
            continue\r
        \r
        Logger.Error("PackagingTool", FILE_TYPE_MISMATCH,\r
            ExtraData=ST.ERR_DIST_FILE_TOOMANY)\r
    if not DescFile or not ContentFile:\r
        Logger.Error("PackagingTool", FILE_UNKNOWN_ERROR,\r
            ExtraData=ST.ERR_DIST_FILE_TOOFEW)\r
    return DescFile, ContentFile\r
\r