windows-xp/Source/XPSP1/NT/tools/autostart.js

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1995
//
//  File:       autostart.js
//
//  Contents:   A script which will connect to a Build Manager machine and
//              start a build. This can be used to start builds automatically
//              with the task scheduler or by scripts.
//
//----------------------------------------------------------------------------

var RemoteObj = null;

var DEFAULT_IDENTITY_BM = "BuildManager";
var DEFAULT_IDENTITY_BUILDER = "Build";
var strBldMgr;
var strBldMgrIdentity = DEFAULT_IDENTITY_BM;
var strConfigURL = null;
var strEnviroURL = null;

var strConfigXML;
var strEnviroXML;
var strTimeStamp;

var fForceRestart   = false;
var fCreateMachines = false;
var fUpdateBinaries = false;
var fSetTimeStamp   = false;
var fTryAgain       = true;

var aMachines = new Array();

// Capture variables
var fCaptureLogsFromMachine;
var fCaptureLogs;
var strCaptureLogDir;
var strCaptureLogMan;
var strCaptureLogManIdentity;
var g_FSObj;

var vRet = 0;
//
// First, parse command line arguments
//
Error.prototype.toString         = Error_ToString;
ParseArguments(WScript.Arguments);

if (fUpdateBinaries)
{
    vRet = DoBinariesUpdate();
}
else if (fCaptureLogs)
{
    g_FSObj = new ActiveXObject("Scripting.FileSystemObject");    // Parse input Parameter List
    if (fCaptureLogsFromMachine)
        vRet = CaptureLogsManager(strCaptureLogDir, strCaptureLogMan, strCaptureLogManIdentity);
    else
        vRet = CaptureLogsEnviro(strCaptureLogDir);
}
else
{
    vRet = AutoStart();
}

WScript.Quit(vRet);

function ParseArguments(Arguments)
{
    var strArg;
    var chArg0;
    var chArg1;
    var argn;

    for(argn = 0; argn < Arguments.length; argn++)
    {
        strArg = Arguments(argn);
        chArg0 = strArg.charAt(0);
        chArg1 = strArg.toLowerCase().slice(1);

        if (chArg0 != '-' && chArg0 != '/')
        {
            if (!strConfigURL)
                strConfigURL = Arguments(argn);
            else if (!strEnviroURL )
                strEnviroURL = Arguments(argn);
            else
                Usage(1);
        }
        else
        {
            switch(chArg1)
            {
                case 'f':
                    fForceRestart = true;
                    break;
                case 'u':
                    fUpdateBinaries = true;
                    fCreateMachines = true;
                    break;
                case 't':
                    fSetTimeStamp = true;
                    argn++;
                    if (argn < Arguments.length)
                        strTimeStamp = Arguments(argn);
                    else
                        Usage(1);
                    break;
                case 'log':
                    fCaptureLogs = true;
                    argn++;
                    if (argn < Arguments.length)
                        strCaptureLogDir = Arguments(argn);
                    else
                        Usage(2);
                    fCreateMachines = true;
                    break;
                case 'logman':
                    fCaptureLogsFromMachine = true;
                    argn++;
                    if (argn < Arguments.length)
                        strCaptureLogMan = Arguments(argn);
                    else
                        Usage(3);
                    argn++;
                    if (argn < Arguments.length)
                        strCaptureLogManIdentity = Arguments(argn);
                    else
                        Usage(4);
                    break;
                default:
                    Usage(5);
                    break;
            }
        }
    }
    // Insist that the config and enviro templates are supplied.
    if (!fCaptureLogsFromMachine && (!strConfigURL || !strEnviroURL))
    {
        if (!fCaptureLogs)
        {
            WScript.Echo('!fCaptureLogsFromMachine' + !fCaptureLogsFromMachine);
            WScript.Echo('!strConfigURL' + !strConfigURL);
            WScript.Echo('!strEnviroURL' + !strEnviroURL);
            Usage(6);
        }
    }
    if (fCaptureLogsFromMachine && !fCaptureLogs)
        Usage(7);
}

function AutoStart()
{
    try
    {
        var ret;
        var err = new Error();
        var PublicData;

        LoadEnvironmentTemplate();
        LoadConfigTemplate();

        try
        {
            var objOD = new ActiveXObject('MTScript.ObjectDaemon', strBldMgr)
            RemoteObj = objOD.OpenInterface(strBldMgrIdentity, 'MTScript.Remote', true);
        }
        catch(ex)
        {
            if (strBldMgr && strBldMgr.length > 0)
                err.description = 'Sorry. Could not connect to machine "' + strBldMgr + '\\' + strBldMgrIdentity + '"';
            else
                err.description = 'Sorry. Could not connect to the local machine.';

            err.description += '\n\tVerify that the machine is available and that mtscript.exe\n\tis running on the machine.';

            err.details = ex.description;

            throw(err);
        }

        PublicData = RemoteObj.Exec('getpublic', 'root');
        PublicData = eval(PublicData);

        CommonVersionCheck("$DROPVERSION: V(2463.0  ) F(autostart.js  )$", PublicData);

        // Check the current mode of the machine. If it's idle, then switch it
        // into master or standalone mode and get it going.
        if (PublicData.strMode != 'idle')
        {
            if (fForceRestart)
            {
                WScript.Echo('The machine is not idle. Forcing a restart...');

                ret = RemoteObj.Exec('setmode', 'idle');

                WScript.Sleep(5000);
            }
            else
            {
                WScript.Echo('The machine is not idle. Use -f to force a restart.');

                return 1;
            }
        }

        while (!StartBuild() && fTryAgain)
        {
            ret = RemoteObj.Exec('setmode', 'idle');

            WScript.Sleep(5000);

            fTryAgain = false;
        }

        WScript.Echo('Build started successfully.');
    }
    catch(ex)
    {
        WScript.Echo('An error occurred starting the build:');
        WScript.Echo('\t' + ex);
        WScript.Echo('');

        return 1;
    }
    return 0;
}

function MachineInfo()
{
    this.strName = '';
    this.strEnlistment = '';
    this.fPostBuild = false;
}

function StartBuild()
{
    var ret = 'ok';
    var err = new Error();

    if (fSetTimeStamp)
    {
        ret = RemoteObj.Exec('setstringmap', "%today%=" + strTimeStamp);
    }

    if (ret == 'ok')
    {
        ret = RemoteObj.Exec('setconfig', strConfigXML);

        if (ret == 'ok')
        {
            ret = RemoteObj.Exec('setenv', strEnviroXML);

            if (ret == 'ok')
            {
                ret = RemoteObj.Exec('setmode', 'master');

                if (ret == 'ok')
                {
                    ret = RemoteObj.Exec('start', '');
                }
            }
            else
                err.description = 'An error occurred loading the environment template';
        }
        else if (ret == 'alreadyset')
        {
            // The machine is busy. Reset it if necessary.
            return false;
        }
        else
            err.description = 'An error occurred loading the build template';
    }
    else
        err.description = 'An error occurred setting the timestamp.';

    if (ret != 'ok')
    {
        if (!err.description)
            err.description = 'A failure occurred communicating with the machine.';

        err.details = ret;

        throw(err);
    }

    return true;
}

function LoadEnvironmentTemplate()
{
    var xml = new ActiveXObject('Microsoft.XMLDOM');
    var err = new Error();
    var node;

    fStandaloneMode = false;

    xml.async = false;
    // It's unlikely they have the schema file available for this template,
    // so we turn off schema validation right now. The script engine will
    // validate it when we start the build.
    xml.validateOnParse = false;
    xml.resolveExternals = false;

    if (!xml.load(strEnviroURL) || !xml.documentElement)
    {
        err.description = 'Error loading the environment template ' + strEnviroURL;
        err.details = xml.parseError.reason;

        throw(err);
    }

    node = xml.documentElement.selectSingleNode('BuildManager');

    if (!node)
    {
        err.description = 'Invalid environment template file (BuildManager tag missing): ' + strEnviroURL;
        throw(err);
    }

    strBldMgr = node.getAttribute("Name");
    strBldMgrIdentity = node.getAttribute("Identity");

    if (!strBldMgr)
    {
        err.description = 'Invalid environment template file (BuildManager tag badly formatted): ' + strEnviroURL;
        throw(err);
    }
    if (!strBldMgrIdentity)
        strBldMgrIdentity = DEFAULT_IDENTITY_BM;

    if (strBldMgr.toLowerCase() == '%localmachine%' ||
        strBldMgr.toLowerCase() == '%remotemachine%')
    {
        err.description = 'Sorry, cannot use the local machine or remote machine templates from this script';

        throw(err);
    }

    strEnviroXML = 'XML: ' + xml.xml;

    if (fCreateMachines)
    {
        var node;
        var strPostBuild;
        var nodelist;
        var objMach;

        // Build the list of machines so we can copy the binaries from each
        // one.

        strPostBuild = node.getAttribute("PostBuildMachine");

        nodelist = xml.documentElement.selectNodes('Machine');

        for (node = nodelist.nextNode();
             node;
             node = nodelist.nextNode())
        {
            objMach = new MachineInfo();

            objMach.strName = node.getAttribute("Name");
            objMach.strEnlistment = node.getAttribute("Enlistment");
            objMach.Identity = node.getAttribute("Identity");
            if (!objMach.Identity || objMach.Identity == '')
                objMach.Identity = DEFAULT_IDENTITY_BUILDER;

            if (objMach.strName.toLowerCase() == strPostBuild.toLowerCase())
            {
                objMach.fPostBuild = true;
            }

            aMachines[aMachines.length] = objMach;
        }
    }

    return true;
}

function LoadConfigTemplate()
{
    var xml = new ActiveXObject('Microsoft.XMLDOM');
    var err = new Error();

    xml.async = false;
    // It's unlikely they have the schema file available for this template,
    // so we turn off schema validation right now. The script engine will
    // validate it when we start the build.
    xml.validateOnParse = false;
    xml.resolveExternals = false;

    if (!xml.load(strConfigURL) || !xml.documentElement)
    {
        err.description = 'Error loading the config template ' + strConfigURL;
        err.details = xml.parseError.reason;

        throw(err);
    }

    strConfigXML = 'XML: ' + xml.xml;

    return true;
}

function GetBinariesUNC(mach)
{
    var strUNC;

    strUNC = '\\\\' + mach.strName + '\\';

    try
    {
        var objOD = new ActiveXObject('MTScript.ObjectDaemon', mach.strName)
        RemoteObj = objOD.OpenInterface(mach.Identity, 'MTScript.Remote', true);
    }
    catch(ex)
    {
        err.description = 'Sorry. Could not connect to machine "' + mach.strName + '"';

        err.description += '\n\tVerify that the machine is available and that mtscript.exe\n\tis running on the machine.';

        err.details = ex.description;

        throw(err);
    }

    try
    {
        strUNC += eval(RemoteObj.Exec('getpublic', 'PrivateData.aEnlistmentInfo[0].hEnvObj["_nttree"]'));
    }
    catch(ex)
    {
        err.description = 'Machine ' + mach.strName + '\\' + mach.Identity + ' is not in the correct state. ';
        err.description += 'The binaries location cannot be determined. (Was the machine reset?)';

        err.details = ex.description;

        throw(err);
    }

    strUNC = strUNC.replace(/\:/ig, '$');

    return strUNC;
}

function DoBinariesUpdate()
{
    try
    {
        LoadEnvironmentTemplate();
        LoadConfigTemplate();

        // The postbuild machine must always be the first machine listed
        var i;

        for (i = 0; i < aMachines.length; i++)
        {
            if (aMachines[i].fPostBuild)
            {
                WScript.Echo(aMachines[i].strName + "\\" + aMachines[i].Identity + " " + GetBinariesUNC(aMachines[i]));
            }
        }

        for (i = 0; i < aMachines.length; i++)
        {
            if (!aMachines[i].fPostBuild)
            {
                WScript.Echo(aMachines[i].strName + "\\" + aMachines[i].Identity + " " + GetBinariesUNC(aMachines[i]));
            }
        }
    }
    catch(ex)
    {
        WScript.Echo('An error occurred during update binaries:');
        WScript.Echo('\t' + ex);
        WScript.Echo('');
        return 1;
    }
    return 0;
}

function Error_ToString()
{
    var i;
    var str = 'Exception(';

    /*
        Only some error messages get filled in for "ex".
        Specifically the text for disk full never seems
        to get set by functions such as CreateTextFile().


     */
    if (this.number != null && this.description == "")
    {
        switch(this.number)
        {
            case -2147024784:
                this.description = "There is not enough space on the disk.";
                break;
            case -2147024894:
                this.description = "The system cannot find the file specified.";
                break;
            case -2147023585:
                this.description = "There are currently no logon servers available to service the logon request.";
                break;
            case -2147023170:
                this.description = "The remote procedure call failed.";
                break;
            case -2147024837:
                this.description = "An unexpected network error occurred";
                break;
            case -2147024890:
                this.description = "The handle is invalid.";
                break;
            default:
                this.description = "Error text not set for (" + this.number + ")";
                break;
        }
    }
    for(i in this)
    {
        str += i + ": " + this[i] + " ";
    }
    return str + ")";
}

// MyEval(expr)
// evaluating uneval'ed objects creates a bunch of junk local variables.
// by putting the eval call in a little subroutine, we avoid keeping those
// locals around.
function MyEval(expr)
{
    try
    {
        return eval(expr);
    }
    catch(ex)
    {
        throw ex;
    }
}
// CopyFileNoThrow(strSrc, strDst)
// Wrap the FSObj.CopyFile call to prevent it from
// throwing its errors.
function CopyFileNoThrow(strSrc, strDst)
{
    try
    {
        g_FSObj.CopyFile(strSrc, strDst, true);
    }
    catch(ex)
    {
        WScript.Echo("Copy failed from " + strSrc + " to " + strDst + " " + ex);
        return ex;
    }
    return null;
}

// CreateFolderNoThrow(strSrc, strDst)
// Wrap the FSObj.MakeFolder call to prevent it from
// throwing its errors.
function CreateFolderNoThrow(strName)
{
    try
    {
        g_FSObj.CreateFolder(strName);
    }
    catch(ex)
    {
        return ex;
    }
    return null;
}

// DirScanNoThrow(strDir)
// Wrap the FSObj.Directory scan functionality to prevent it from
// throwing its errors.
function DirScanNoThrow(strDir)
{
    var aFiles = new Array();
    try
    {
        var folder;
        var fc;

        folder = g_FSObj.GetFolder(strDir);
        fc = new Enumerator(folder.files);
        for (; !fc.atEnd(); fc.moveNext())
        {
            aFiles[aFiles.length] = fc.item().Name; // fc.item() returns entire path, fc.item().Name is just the filename
        }
    }
    catch(ex)
    {
        aFiles.ex = ex;
    }
    return aFiles;
}

//
// CopyDirectory
//    Do a non-recursive directory copy.
//
function CopyDirectory(strSrcDir, strDestDir)
{
    var ret = true;
    var ex;
    var aFiles;
    var strFileName = '';
    var i;

    WScript.Echo("Copy from " + strSrcDir + " to " + strDestDir);
    aFiles = DirScanNoThrow(strSrcDir);
    if (aFiles.ex)
    {
        WScript.Echo('Could not dirscan ' + strSrcDir + ', ex=' + ex);
        return false;
    }
    else
    {
        for(i = 0; i < aFiles.length; ++i)
        {
            strFileName = aFiles[i];
            ex = CopyFileNoThrow(
                    strSrcDir + '\\' + strFileName,
                    strDestDir + '\\' + strFileName);

            if (ex)
            {
                WScript.Echo("\t FAILED: " + strFileName);
                ret = false;
            }
            else
                WScript.Echo("\t COPIED: " + strFileName);
        }
    }
    return ret;
}

//
// CopyMTScriptLog()
//  Copy the highest numbers "mtscript" log file
//  from the specified machine.
//
function CopyMTScriptLog(strMachineName, strIdentity, strDestDir)
{
    var nLargestIndex = 0;
    var aReResult;
    var re = new RegExp('^' + strMachineName + '_' + strIdentity + '_MTS.([0-9]+).log$', 'i'); // match files "BUILDCON2_MTScript.051.log"
    var ex;
    var aFiles;
    var strFileName = '';
    var i;
    var strSrcDir = '\\\\' + strMachineName + "\\bc_build_logs";

    aFiles = DirScanNoThrow(strSrcDir);
    if (aFiles.ex)
        WScript.Echo('Could not dirscan ' + strSrcDir + ', ex=' + ex );
    else
    {
        for(i = 0; i < aFiles.length; ++i)
        {
            aReResult = re.exec(aFiles[i]);
            if (aReResult && Number(aReResult[1]) > nLargestIndex)
            {
                nLargestIndex = Number(aReResult[1]);
                strFileName = aFiles[i];
            }
        }
        if (strFileName == '')
            WScript.Echo("No MTSCRIPT log files on " + strMachineName);
        else
        {
            WScript.Echo("Copy from " + strSrcDir + '\\' + strFileName + " to " + strDestDir + '\\' + g_FSObj.GetFilename(strFileName));
            ex = CopyFileNoThrow(strSrcDir + '\\' + strFileName, strDestDir + '\\' + g_FSObj.GetFilename(strFileName));
            if (ex)
            {
                WScript.Echo("Failed " + ex);
                return false;
            }
        }
    }
    return true;
}

//
// CopyLogFiles()
//  Copy the build log files from the given machines.
//
function CopyLogFiles(strDestDir, strBuildManagerName, strBuildManagerIdentity, aMachines)
{
    var i;
    var strDest;

    CreateFolderNoThrow(strDestDir);
    CopyMTScriptLog(strBuildManagerName, strBuildManagerIdentity, strDestDir);
    for( i = 0; i < aMachines.length; ++i)
    {
        CopyMTScriptLog(aMachines[i].strName, aMachines[i].Identity, strDestDir);
    }
    /*
        Note: The following code tries to guess the filenames of the build log files.
        The "real" information can be had from the PublicData of the build manager.
            PublicData.aBuild[0].aDepot[ x ].aTask[ y ].strLogPath
            PublicData.aBuild[0].aDepot[ x ].aTask[ y ].strErrLogPath

        Of course, that would require that the build manager is still alive and well.
    */
    for( i = 0; i < aMachines.length; ++i)
    {
        strDest = strDestDir + "\\" + aMachines[i].strName;
        CreateFolderNoThrow(strDest);

        strDest += '\\' + aMachines[i].Identity;
        CreateFolderNoThrow(strDest);

        CopyDirectory("\\\\" + aMachines[i].strName + "\\bc_build_logs\\build_logs\\" + aMachines[i].Identity,
                        strDestDir + "\\" + aMachines[i].strName + '\\' + aMachines[i].Identity);
    }
}

//
// CaptureLogsManager()
//  Connect to the given build manager
//  and query it for its list of build machines,
//  The copy the MTSCRIPT and build log files from
//  each of those machines.
//
function CaptureLogsManager(strLogDir, strMachineName, strIdentity)
{
    var strMode;
    var obj;
    try
    {
        WScript.Echo("Attempting connection to " + strMachineName + "\\" + strIdentity);
        obj = new ActiveXObject('MTScript.Proxy');
        WScript.Echo("Now connecting");
        obj.ConnectToMTScript(strMachineName, strIdentity, false);

        strMode = obj.Exec('getpublic', 'PublicData.strMode');
        strMode = MyEval(strMode);
        if (strMode == 'idle')
        {
            WScript.Echo(strMachineName + "\\" + strIdentity + " is currently idle");
            return 1;
        }

        aMachines = obj.Exec('getpublic', 'PrivateData.objEnviron.Machine');
        aMachines = MyEval(aMachines);
        for( i = 0; i < aMachines.length; ++i)
        {
            aMachines[i].strName = aMachines[i].Name;
            if (!aMachines[i].Identity || aMachines[i].Identity == '')
                aMachines[i].Identity = DEFAULT_IDENTITY_BUILDER;
        }
        CopyLogFiles(strLogDir, strMachineName, strIdentity, aMachines);
    }
    catch(ex)
    {
        WScript.Echo("CaptureLogsManager '" + strMachineName + "\\" + strIdentity + "' failed, ex=" + ex);
        return 1;
    }
    return 0;
}

//
// CaptureLogsEnviro()
//  Read the supplied environment template
//  and copy the MTSCRIPT and build logs
//  from each of the specifed build machines.
//
function CaptureLogsEnviro(strLogDir)
{
    try
    {
        var ret;
        if (!strEnviroURL && strConfigURL)
        {
            strEnviroURL = strConfigURL;
            strConfigURL = null;
        }
        LoadEnvironmentTemplate();

        ret = CopyLogFiles(strLogDir, strBldMgr, strBldMgrIdentity, aMachines);
    }
    catch(ex)
    {
        WScript.Echo('An error occurred capturing log files:');
        WScript.Echo('\t ex=' + ex);
        WScript.Echo('');
        return 1;
    }
    return 0;
}

/*
    CommonVersionCheck(strLocalVersion, PublicData)

    Ensure that this script and the remote script are running the same version.
    A copy of this function exists in:
    autostart.js
    bldcon.hta
    utils.js
 */
function CommonVersionCheck(strLocalVersion, PublicData)
{
    var err = new Error();
    var reBuildNum = new RegExp("V\\(([#0-9. ]+)\\)");
    var aLocal = reBuildNum.exec(strLocalVersion);
    var aPublicBuildNum;

    if (!PublicData.strDataVersion)
    {
        err.description = "autostart version mismatch";
        err.details = "Build Manager does not have a version string";
        throw err;
    }
    aPublicBuildNum = reBuildNum.exec(PublicData.strDataVersion);
    if (!aLocal || !aPublicBuildNum)
    {
        err.description = "Invalid version format";
        err.details = "UI Version: " + strLocalVersion + ", Build Manager Version: " + PublicData.strDataVersion;
        throw err;
    }

    if (aLocal[1] != aPublicBuildNum[1])
    {
        err.description = "Version mismatch";
        err.details = "UI Version: " + strLocalVersion + ", Build Manager Version: " + PublicData.strDataVersion;
        throw err;
    }
}

function Usage(x)
{
    WScript.Echo('');
    WScript.Echo('Usage: bcauto [-f] [-u] [-t] <config> <enviro>');
    WScript.Echo('');
    WScript.Echo('    -f              : If the machine is busy, terminate the build and restart.');
    WScript.Echo('    -u              : Update: Recombine all the binaries from each of the build');
    WScript.Echo('                      machines after taking incremental fixes so that postbuild');
    WScript.Echo('                      can be run again.');
    WScript.Echo('    -t <timestamp>  : Use timestamp (e.g. 2001/12/15:12:00)');
    WScript.Echo('    -log dir        : Capture log files to specified directory');
    WScript.Echo('    -logman machine identity : Query "machine" with "identity" for list of');
    WScript.Echo('                               build machines instead of template files.');
    WScript.Echo('                               ("machine" must be a build manager)');
    WScript.Echo('    config          : URL or path for the build template.');
    WScript.Echo('    enviro          : URL or path for the environment template.');
    WScript.Echo('');
    WScript.Quit(1);
}