BaseTools/BinToPcd: Fix Python 2.7.x compatibility issue

[mirror_edk2.git] / BaseTools / Scripts / UpdateBuildVersions.py

## @file\r
# Update build revisions of the tools when performing a developer build\r
#\r
# This script will modife the C/Include/Common/BuildVersion.h file and the two\r
# Python scripts, Python/Common/BuildVersion.py and Python/UPT/BuildVersion.py.\r
# If SVN is available, the tool will obtain the current checked out version of\r
# the source tree for including the the --version commands.\r
\r
#  Copyright (c) 2014 - 2015, Intel Corporation. All rights reserved.<BR>\r
#\r
#  This program and the accompanying materials\r
#  are licensed and made available under the terms and conditions of the BSD License\r
#  which accompanies this 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
""" This program will update the BuildVersion.py and BuildVersion.h files used to set a tool's version value """\r
from __future__ import absolute_import\r
\r
import os\r
import shlex\r
import subprocess\r
import sys\r
\r
from argparse import ArgumentParser, SUPPRESS\r
from tempfile import NamedTemporaryFile\r
from types import IntType, ListType\r
\r
\r
SYS_ENV_ERR = "ERROR : %s system environment variable must be set prior to running this tool.\n"\r
\r
__execname__ = "UpdateBuildVersions.py"\r
SVN_REVISION = "$LastChangedRevision: 3 $"\r
SVN_REVISION = SVN_REVISION.replace("$LastChangedRevision:", "").replace("$", "").strip()\r
__copyright__ = "Copyright (c) 2014, Intel Corporation. All rights reserved."\r
VERSION_NUMBER = "0.7.0"\r
__version__ = "Version %s.%s" % (VERSION_NUMBER, SVN_REVISION)\r
\r
\r
def ParseOptions():\r
    """\r
    Parse the command-line options.\r
    The options for this tool will be passed along to the MkBinPkg tool.\r
    """\r
    parser = ArgumentParser(\r
        usage=("%s [options]" % __execname__),\r
        description=__copyright__,\r
        conflict_handler='resolve')\r
\r
    # Standard Tool Options\r
    parser.add_argument("--version", action="version",\r
                        version=__execname__ + " " + __version__)\r
    parser.add_argument("-s", "--silent", action="store_true",\r
                        dest="silent",\r
                        help="All output will be disabled, pass/fail determined by the exit code")\r
    parser.add_argument("-v", "--verbose", action="store_true",\r
                        dest="verbose",\r
                        help="Enable verbose output")\r
    # Tool specific options\r
    parser.add_argument("--revert", action="store_true",\r
                        dest="REVERT", default=False,\r
                        help="Revert the BuildVersion files only")\r
    parser.add_argument("--svn-test", action="store_true",\r
                        dest="TEST_SVN", default=False,\r
                        help="Test if the svn command is available")\r
    parser.add_argument("--svnFlag", action="store_true",\r
                        dest="HAVE_SVN", default=False,\r
                        help=SUPPRESS)\r
\r
    return(parser.parse_args())\r
\r
\r
def ShellCommandResults(CmdLine, Opt):\r
    """ Execute the comand, returning the output content """\r
    file_list = NamedTemporaryFile(delete=False)\r
    filename = file_list.name\r
    Results = []\r
\r
    returnValue = 0\r
    try:\r
        subprocess.check_call(args=shlex.split(CmdLine), stderr=subprocess.STDOUT, stdout=file_list)\r
    except subprocess.CalledProcessError as err_val:\r
        file_list.close()\r
        if not Opt.silent:\r
            sys.stderr.write("ERROR : %d : %s\n" % (err_val.returncode, err_val.__str__()))\r
            if os.path.exists(filename):\r
                sys.stderr.write("      : Partial results may be in this file: %s\n" % filename)\r
            sys.stderr.flush()\r
        returnValue = err_val.returncode\r
\r
    except IOError as err_val:\r
        (errno, strerror) = err_val.args\r
        file_list.close()\r
        if not Opt.silent:\r
            sys.stderr.write("I/O ERROR : %s : %s\n" % (str(errno), strerror))\r
            sys.stderr.write("ERROR : this command failed : %s\n" % CmdLine)\r
            if os.path.exists(filename):\r
                sys.stderr.write("      : Partial results may be in this file: %s\n" % filename)\r
            sys.stderr.flush()\r
        returnValue = errno\r
\r
    except OSError as err_val:\r
        (errno, strerror) = err_val.args\r
        file_list.close()\r
        if not Opt.silent:\r
            sys.stderr.write("OS ERROR : %s : %s\n" % (str(errno), strerror))\r
            sys.stderr.write("ERROR : this command failed : %s\n" % CmdLine)\r
            if os.path.exists(filename):\r
                sys.stderr.write("      : Partial results may be in this file: %s\n" % filename)\r
            sys.stderr.flush()\r
        returnValue = errno\r
\r
    except KeyboardInterrupt:\r
        file_list.close()\r
        if not Opt.silent:\r
            sys.stderr.write("ERROR : Command terminated by user : %s\n" % CmdLine)\r
            if os.path.exists(filename):\r
                sys.stderr.write("      : Partial results may be in this file: %s\n" % filename)\r
            sys.stderr.flush()\r
        returnValue = 1\r
\r
    finally:\r
        if not file_list.closed:\r
            file_list.flush()\r
            os.fsync(file_list.fileno())\r
            file_list.close()\r
\r
    if os.path.exists(filename):\r
        fd_ = open(filename, 'r')\r
        Results = fd_.readlines()\r
        fd_.close()\r
        os.unlink(filename)\r
\r
    if returnValue > 0:\r
        return returnValue\r
\r
    return Results\r
\r
\r
def UpdateBuildVersionPython(Rev, UserModified, opts):\r
    """ This routine will update the BuildVersion.h files in the C source tree """\r
    for SubDir in ["Common", "UPT"]:\r
        PyPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "Python", SubDir)\r
        BuildVersionPy = os.path.join(PyPath, "BuildVersion.py")\r
        fd_ = open(os.path.normpath(BuildVersionPy), 'r')\r
        contents = fd_.readlines()\r
        fd_.close()\r
        if opts.HAVE_SVN is False:\r
            BuildVersionOrig = os.path.join(PyPath, "orig_BuildVersion.py")\r
            fd_ = open (BuildVersionOrig, 'w')\r
            for line in contents:\r
                fd_.write(line)\r
            fd_.flush()\r
            fd_.close()\r
        new_content = []\r
        for line in contents:\r
            if line.strip().startswith("gBUILD_VERSION"):\r
                new_line = "gBUILD_VERSION = \"Developer Build based on Revision: %s\"" % Rev\r
                if UserModified:\r
                    new_line = "gBUILD_VERSION = \"Developer Build based on Revision: %s with Modified Sources\"" % Rev\r
                new_content.append(new_line)\r
                continue\r
            new_content.append(line)\r
\r
        fd_ = open(os.path.normpath(BuildVersionPy), 'w')\r
        for line in new_content:\r
            fd_.write(line)\r
        fd_.close()\r
\r
\r
def UpdateBuildVersionH(Rev, UserModified, opts):\r
    """ This routine will update the BuildVersion.h files in the C source tree """\r
    CPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "C", "Include", "Common")\r
    BuildVersionH = os.path.join(CPath, "BuildVersion.h")\r
    fd_ = open(os.path.normpath(BuildVersionH), 'r')\r
    contents = fd_.readlines()\r
    fd_.close()\r
    if opts.HAVE_SVN is False:\r
        BuildVersionOrig = os.path.join(CPath, "orig_BuildVersion.h")\r
        fd_ = open(BuildVersionOrig, 'w')\r
        for line in contents:\r
            fd_.write(line)\r
        fd_.flush()\r
        fd_.close()\r
\r
    new_content = []\r
    for line in contents:\r
        if line.strip().startswith("#define"):\r
            new_line = "#define __BUILD_VERSION \"Developer Build based on Revision: %s\"" % Rev\r
            if UserModified:\r
                new_line = "#define __BUILD_VERSION \"Developer Build based on Revision: %s with Modified Sources\"" % \\r
                            Rev\r
            new_content.append(new_line)\r
            continue\r
        new_content.append(line)\r
\r
    fd_ = open(os.path.normpath(BuildVersionH), 'w')\r
    for line in new_content:\r
        fd_.write(line)\r
    fd_.close()\r
\r
\r
def RevertCmd(Filename, Opt):\r
    """ This is the shell command that does the SVN revert """\r
    CmdLine = "svn revert %s" % Filename.replace("\\", "/").strip()\r
    try:\r
        subprocess.check_output(args=shlex.split(CmdLine))\r
    except subprocess.CalledProcessError as err_val:\r
        if not Opt.silent:\r
            sys.stderr.write("Subprocess ERROR : %s\n" % err_val)\r
            sys.stderr.flush()\r
\r
    except IOError as err_val:\r
        (errno, strerror) = err_val.args\r
        if not Opt.silent:\r
            sys.stderr.write("I/O ERROR : %d : %s\n" % (str(errno), strerror))\r
            sys.stderr.write("ERROR : this command failed : %s\n" % CmdLine)\r
            sys.stderr.flush()\r
\r
    except OSError as err_val:\r
        (errno, strerror) = err_val.args\r
        if not Opt.silent:\r
            sys.stderr.write("OS ERROR : %d : %s\n" % (str(errno), strerror))\r
            sys.stderr.write("ERROR : this command failed : %s\n" % CmdLine)\r
            sys.stderr.flush()\r
\r
    except KeyboardInterrupt:\r
        if not Opt.silent:\r
            sys.stderr.write("ERROR : Command terminated by user : %s\n" % CmdLine)\r
            sys.stderr.flush()\r
\r
    if Opt.verbose:\r
        sys.stdout.write("Reverted this file: %s\n" % Filename)\r
        sys.stdout.flush()\r
\r
\r
def GetSvnRevision(opts):\r
    """ Get the current revision of the BaseTools/Source tree, and check if any of the files have been modified """\r
    Revision = "Unknown"\r
    Modified = False\r
\r
    if opts.HAVE_SVN is False:\r
        sys.stderr.write("WARNING: the svn command-line tool is not available.\n")\r
        return (Revision, Modified)\r
\r
    SrcPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source")\r
    # Check if there are modified files.\r
    Cwd = os.getcwd()\r
    os.chdir(SrcPath)\r
\r
    StatusCmd = "svn st -v --depth infinity --non-interactive"\r
    contents = ShellCommandResults(StatusCmd, opts)\r
    os.chdir(Cwd)\r
    if isinstance(contents, ListType):\r
        for line in contents:\r
            if line.startswith("M "):\r
                Modified = True\r
                break\r
\r
    # Get the repository revision of BaseTools/Source\r
    InfoCmd = "svn info %s" % SrcPath.replace("\\", "/").strip()\r
    Revision = 0\r
    contents = ShellCommandResults(InfoCmd, opts)\r
    if isinstance(contents, IntType):\r
        return 0, Modified\r
    for line in contents:\r
        line = line.strip()\r
        if line.startswith("Revision:"):\r
            Revision = line.replace("Revision:", "").strip()\r
            break\r
\r
    return (Revision, Modified)\r
\r
\r
def CheckSvn(opts):\r
    """\r
    This routine will return True if an svn --version command succeeds, or False if it fails.\r
    If it failed, SVN is not available.\r
    """\r
    OriginalSilent = opts.silent\r
    opts.silent = True\r
    VerCmd = "svn --version"\r
    contents = ShellCommandResults(VerCmd, opts)\r
    opts.silent = OriginalSilent\r
    if isinstance(contents, IntType):\r
        if opts.verbose:\r
            sys.stdout.write("SVN does not appear to be available.\n")\r
            sys.stdout.flush()\r
        return False\r
\r
    if opts.verbose:\r
        sys.stdout.write("Found %s" % contents[0])\r
        sys.stdout.flush()\r
    return True\r
\r
\r
def CopyOrig(Src, Dest, Opt):\r
    """ Overwrite the Dest File with the Src File content """\r
    try:\r
        fd_ = open(Src, 'r')\r
        contents = fd_.readlines()\r
        fd_.close()\r
        fd_ = open(Dest, 'w')\r
        for line in contents:\r
            fd_.write(line)\r
        fd_.flush()\r
        fd_.close()\r
    except IOError:\r
        if not Opt.silent:\r
            sys.stderr.write("Unable to restore this file: %s\n" % Dest)\r
            sys.stderr.flush()\r
        return 1\r
\r
    os.remove(Src)\r
    if Opt.verbose:\r
        sys.stdout.write("Restored this file: %s\n" % Src)\r
        sys.stdout.flush()\r
\r
    return 0\r
\r
\r
def CheckOriginals(Opts):\r
    """\r
    If SVN was not available, then the tools may have made copies of the original BuildVersion.* files using\r
    orig_BuildVersion.* for the name. If they exist, replace the existing BuildVersion.* file with the corresponding\r
    orig_BuildVersion.* file.\r
    Returns 0 if this succeeds, or 1 if the copy function fails. It will also return 0 if the orig_BuildVersion.* file\r
    does not exist.\r
    """\r
    CPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "C", "Include", "Common")\r
    BuildVersionH = os.path.join(CPath, "BuildVersion.h")\r
    OrigBuildVersionH = os.path.join(CPath, "orig_BuildVersion.h")\r
    if not os.path.exists(OrigBuildVersionH):\r
        return 0\r
    if CopyOrig(OrigBuildVersionH, BuildVersionH, Opts):\r
        return 1\r
    for SubDir in ["Common", "UPT"]:\r
        PyPath = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "Python", SubDir)\r
        BuildVersionPy = os.path.join(PyPath, "BuildVersion.h")\r
        OrigBuildVersionPy = os.path.join(PyPath, "orig_BuildVersion.h")\r
        if not os.path.exists(OrigBuildVersionPy):\r
            return 0\r
        if CopyOrig(OrigBuildVersionPy, BuildVersionPy, Opts):\r
            return 1\r
\r
    return 0\r
\r
\r
def RevertBuildVersionFiles(opts):\r
    """\r
    This routine will attempt to perform an SVN --revert on each of the BuildVersion.* files\r
    """\r
    if not opts.HAVE_SVN:\r
        if CheckOriginals(opts):\r
            return 1\r
        return 0\r
    # SVN is available\r
    BuildVersionH = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "C", "Include", "Common", "BuildVersion.h")\r
    RevertCmd(BuildVersionH, opts)\r
    for SubDir in ["Common", "UPT"]:\r
        BuildVersionPy = os.path.join(os.environ['BASE_TOOLS_PATH'], "Source", "Python", SubDir, "BuildVersion.py")\r
        RevertCmd(BuildVersionPy, opts)\r
\r
def UpdateRevisionFiles():\r
    """ Main routine that will update the BuildVersion.py and BuildVersion.h files."""\r
    options = ParseOptions()\r
    # Check the working environment\r
    if "WORKSPACE" not in os.environ.keys():\r
        sys.stderr.write(SYS_ENV_ERR % 'WORKSPACE')\r
        return 1\r
    if 'BASE_TOOLS_PATH' not in os.environ.keys():\r
        sys.stderr.write(SYS_ENV_ERR % 'BASE_TOOLS_PATH')\r
        return 1\r
    if not os.path.exists(os.environ['BASE_TOOLS_PATH']):\r
        sys.stderr.write("Unable to locate the %s directory." % os.environ['BASE_TOOLS_PATH'])\r
        return 1\r
\r
\r
    options.HAVE_SVN = CheckSvn(options)\r
    if options.TEST_SVN:\r
        return (not options.HAVE_SVN)\r
    # done processing the option, now use the option.HAVE_SVN as a flag. True = Have it, False = Don't have it.\r
    if options.REVERT:\r
        # Just revert the tools an exit\r
        RevertBuildVersionFiles(options)\r
    else:\r
        # Revert any changes in the BuildVersion.* files before setting them again.\r
        RevertBuildVersionFiles(options)\r
        Revision, Modified = GetSvnRevision(options)\r
        if options.verbose:\r
            sys.stdout.write("Revision: %s is Modified: %s\n" % (Revision, Modified))\r
            sys.stdout.flush()\r
        UpdateBuildVersionH(Revision, Modified, options)\r
        UpdateBuildVersionPython(Revision, Modified, options)\r
\r
    return 0\r
\r
\r
if __name__ == "__main__":\r
    sys.exit(UpdateRevisionFiles())\r
\r
\r