windows-nt/Source/XPSP1/NT/tools/autostart.js
2020-09-26 16:20:57 +08:00

855 lines
23 KiB
JavaScript

//+---------------------------------------------------------------------------
//
// 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);
}