OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
master
Windows-Server-2003/tools/bcdist.js

1494 lines
51 KiB
JavaScript
Raw Permalink Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// System wide constants.
// These constants are not expected to change.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var CLASSID_MTSCRIPT = "{854c316d-c854-4a77-b189-606859e4391b}";
Error.prototype.toString = Error_ToString;
Object.prototype.toString = Object_ToString;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Global constants
// These are subject to change and tuning.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var g_aProcsToKill = ["mtscript.exe", "mshta.exe", "build.exe", "nmake.exe", "mtodaemon.exe"]; // "sleep.exe" is also killed seperately.
// The lists of files to copy.
// g_aCopyBCDistDir and g_aCopyBCDistDirD are the set of files which are in the same directory as this
// script is, and are necessary for the operation of bcdist itself.
// The g_aCopyBCDistDirD files are optional and are only necessary for running a debug MTScript.exe
var g_aCopyBCDistDirScript = ['registermtscript.cmd'];
var g_aCopyBCDistDir = ['bcrunas.exe', 'sleep.exe'];
var g_aCopyBCDistDirD = ['mshtmdbg.dll', 'msvcrtd.dll'];
// The g_aCopyFromScripts files are the Build Console Scripts.
// These files are copied from either the current directory or .\mtscript
var g_aCopyFromScripts = [ 'buildreport.js', 'harness.js', 'master.js', 'msgqueue.js',
'mtscript.js', 'publicdataupdate.js', 'robocopy.js',
'sendmail.js', 'slave.js', 'slaveproxy.js', 'slavetask.js',
'staticstrings.js', 'task.js', 'types.js', 'updatestatusvalue.js',
'utils.js', 'utilthrd.js',
'config_schema.xml', 'enviro_schema.xml'
];
// The g_aCopyFromBin files are the Build Console executable files.
// These files are copied from either the current directory or .\%ARCH% (x86, axp64,...)
var g_aCopyFromBin = [ 'mtscript.exe', 'mtlocal.dll', 'mtscrprx.dll', 'mtrcopy.dll', "mtodaemon.exe", "mtodproxy.dll"];
var g_strDropServer = "\\\\ptt\\cftools\\test\\bcrel";
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Global Variables
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var g_strMyLocation;
var g_objNet;
var g_strLocalHost;
var g_objFS;
var g_strShareDir;
var g_Opts;
if (DoLocalSetup())
{
g_Opts = ParseArguments(new DefaultArguments());
if (g_Opts)
{
if (main(g_Opts))
WScript.Quit(0);
}
}
WScript.Quit(1);
// GetMachineList(objArgs) //
// //
// Reads the XML BC environment template to extract the //
// list of machines in the build. //
// //
function GetMachineList(objArgs)
{
var xml = new ActiveXObject('Microsoft.XMLDOM');
var node;
var nodelist;
var objMach;
var nIndex;
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(objArgs.strXMLFile) || !xml.documentElement)
{
Usage("Not a valid xml file: " + objArgs.strXMLFile);
}
node = xml.documentElement.selectSingleNode('BuildManager');
if (!node)
{
Usage("Not a valid xml file: " + objArgs.strXMLFile);
}
objArgs.aMachines[0] = new MachineInfo(node.getAttribute("Name"));
objArgs.aMachines[0].WriteStatusInfo("Initializing");
nodelist = xml.documentElement.selectNodes('Machine');
for (node = nodelist.nextNode(); node; node = nodelist.nextNode())
{
// Don't initialize the build manager machine twice
// just because it is also used in the building process
if ( objArgs.aMachines[0].strName.toLowerCase() == node.getAttribute("Name").toLowerCase() )
continue;
nIndex = objArgs.aMachines.length;
objArgs.aMachines[nIndex] = new MachineInfo(node.getAttribute("Name"));
objArgs.aMachines[nIndex].WriteStatusInfo("Initializing");
}
}
// GetStringArgument(objArgs, strMember) //
// //
// Helper function for ParseArguments. Stores the //
// next argument in the "strMember" member of "objArgs". //
// Exits script with Usage() if there is no available argument. //
function GetStringArgument(objArgs, strMember)
{
if (objArgs[strMember] == null)
{
LogMsg("ParseArguments internal error: Unknown member: " + strMember);
WScript.Quit(1);
}
objArgs.argn++;
if (objArgs.argn < objArgs.objArguments.length)
objArgs[strMember] = objArgs.objArguments(objArgs.argn);
else
Usage("missing paramter");
}
function ParseArguments(objArgs)
{
var strArg;
var chArg0;
var chArg1;
var nIndex;
var fMachineList = false;
for(objArgs.argn = 0; objArgs.argn < objArgs.objArguments.length; objArgs.argn++)
{
strArg = objArgs.objArguments(objArgs.argn);
chArg0 = strArg.charAt(0);
chArg1 = strArg.toLowerCase().slice(1);
if (chArg0 != '-' && chArg0 != '/')
{
if (objArgs.strXMLFile != '')
{
Usage("Enter an XML file or a list of the machines but not both");
}
else
{
fMachineList = true;
nIndex = objArgs.aMachines.length;
objArgs.aMachines[nIndex] = new MachineInfo(strArg);
objArgs.aMachines[nIndex].WriteStatusInfo("Initializing");
}
}
else
{
// Currently, no options
switch(chArg1)
{
case 'v':
objArgs.fVerbose = true;
break;
case 'd':
objArgs.argn++;
if (objArgs.argn < objArgs.objArguments.length)
{
if (objArgs.strSrcDir == '')
objArgs.nDropNum = Number(objArgs.objArguments(objArgs.argn));
else
Usage("Only one of -src and -d may be specified");
}
else
Usage("missing parameter for -d arugment");
if (objArgs.nDropNum < 1000 || objArgs.nDropNum >= 10000)
Usage("dropnum range is 1000...9999");
break;
case 'dropsrc':
GetStringArgument(objArgs, "strDropSrc");
break;
case 'src':
GetStringArgument(objArgs, "strSrcDir");
break;
case 'dst':
GetStringArgument(objArgs, "strDstDir");
break;
case 'u':
GetStringArgument(objArgs, "strUserName");
if (objArgs.strUserName == '*')
{
objArgs.strUserName = g_objNet.UserDomain + '\\' + g_objNet.UserName;
}
break;
//case 'p':
// GetStringArgument(objArgs, "strPassword");
// break;
case 'arch':
GetStringArgument(objArgs, "strArch");
break;
case 'f': // Entered an XML file on the command line. Get the list of machines from here.
if (fMachineList)
Usage("Enter an XML file or a list of the machines but not both");
GetStringArgument(objArgs, "strXMLFile");
GetMachineList(objArgs);
nIndex = objArgs.aMachines.length;
break;
case 'debug':
objArgs.strExeType = 'debug';
break;
default:
Usage("Unknown argument: " + strArg);
break;
}
}
}
if (objArgs.aMachines.length == 0)
Usage("you must specify one or more machine names or an XML file");
if (objArgs.nDropNum)
objArgs.strSrcDir = objArgs.strDropSrc + "\\" + objArgs.nDropNum;
else if (objArgs.strSrcDir == '')
Usage("you must specify a drop number or source location");
//if (objArgs.strUserName == '' || objArgs.strPassword == '')
// Usage("username and password required");
WScript.StdOut.Write('Enter Password:');
objArgs.strPassword = WScript.StdIn.ReadLine();
delete objArgs.objArguments;
delete objArgs.argn;
return objArgs;
}
function Usage(strError)
{
WScript.Echo('');
WScript.Echo('Usage: BCDist -u domain\\username ');
WScript.Echo(' [-v] [-d nnnn [-dropsrc path] | -src path] ');
WScript.Echo(' [-dst path] [-arch x86] [-debug] machines...');
WScript.Echo(' -u d\\u = domain\\username');
WScript.Echo(' -f xmlFile = environment xml template');
WScript.Echo(' -v = verbose');
WScript.Echo(' -d = drop number');
WScript.Echo(' -dropsrc = drop source location ("' + g_strDropServer + '")');
WScript.Echo(' -src = source directory');
WScript.Echo(' -dst = destination directory');
WScript.Echo(' -arch = Specifiy x86 or alpha');
WScript.Echo(' -debug = copy debug exes instead of retail');
WScript.Echo('Do NOT enter the password on the command line');
if (strError && strError != '')
{
WScript.Echo('');
WScript.Echo('Error: ' + strError);
}
WScript.Quit(1);
}
// DefaultArguments() //
// //
// Create an options object with the default //
// options filled in. //
function DefaultArguments()
{
var obj =
{
objArguments:WScript.Arguments,
argn:0,
aMachines:new Array(),
fVerbose:false,
nDropNum:0,
strDropSrc:g_strDropServer,
strSrcDir:'',
strDstDir:'',
strArch:"x86",
strExeType:"retail",
strUserName:'',
strPassword:'',
strXMLFile:''
};
return obj;
}
// DoLocalSetup() //
// //
// Setup some globals. Necessary before arugment parsing //
// can succeed. //
// //
function DoLocalSetup()
{
var i = -1;
var objFile;
var strPath;
var objLogin;
var objRemote;
try
{
g_objNet = WScript.CreateObject("WScript.Network");
g_strLocalHost = g_objNet.ComputerName;
g_objFS = new FileSystemObject();
g_strMyLocation = SplitFileName(WScript.ScriptFullName)[0];
LogMsg("Creating local share...");
objLogin =
{
strMachine:g_strLocalHost
}
objRemote = new WMIInterface(objLogin, '');
g_strShareDir = g_strMyLocation + "bcdiststatus";
g_objFS.CreateFolder(g_strShareDir);
strPath = objRemote.RemoteShareExists("BC_DISTSTATUS");
if (strPath != "")
g_strShareDir = strPath;
else
objRemote.RemoteCreateShare("BC_DISTSTATUS", g_strShareDir, "Build Console Distribution Status");
}
catch(ex)
{
LogMsg("BCDist failed to do local setup: " + ex);
return false;
}
return true;
}
function main(objOpts)
{
var strPath;
var strPathUNC;
var fSuccess = true;
var strDomain = objOpts.strUserName.split("\\")[0];
var strUser = objOpts.strUserName.split("\\")[1];
var fLocal;
var strCmd;
LogMsg("Upgrading the following machines:");
for(i = 0; i < objOpts.aMachines.length;++i)
{
LogMsg(" " + objOpts.aMachines[i].strName);
}
for(i = 0; i < objOpts.aMachines.length;++i)
{
fLocal = false;
strCmd = '';
try
{
LogMsg("Distributing to " + objOpts.aMachines[i].strName);
var objLogin =
{
strMachine:objOpts.aMachines[i].strName,
strUser:objOpts.strUserName, // Unneccessary if the same as the current user.
strPassword:objOpts.strPassword
}
if (objLogin.strMachine.toUpperCase() == g_objNet.ComputerName.toUpperCase())
{ // On the local host you may not specify a username
if (objLogin.strUser.toUpperCase() != (g_objNet.UserDomain + '\\' + g_objNet.UserName).toUpperCase())
throw new Error(-1, "Specified username does not match current login for local machine");
delete objLogin.strUser;
delete objLogin.strPassword;
fLocal = true;
}
objOpts.aMachines[i].WriteStatusInfo("Connecting");
var objRemote = new WMIInterface(objLogin, '');
var objRegistry = new WMIRegistry(objLogin);
objOpts.aMachines[i].WriteStatusInfo("Terminating MTScript.exe");
LogMsg(" Terminating remote processes");
TerminateMTScript(objRemote, objRegistry);
strPath = DetermineInstallPoint(objOpts, objRemote, objRegistry);
strPathUNC = PathToUNC(objOpts.aMachines[i].strName, strPath);
objOpts.aMachines[i].WriteStatusInfo("Copying files");
CopyFiles(objRemote, strPathUNC, objOpts);
objOpts.aMachines[i].WriteStatusInfo("Creating share");
ResetRegistry(objRegistry, strPath);
objOpts.aMachines[i].WriteStatusInfo("Registering");
objOpts.aMachines[i].DisableWriteStatusInfo();
LogMsg(" Registering");
// We don't use BCRunAs when running on the local machine.
if (!fLocal)
{
// Usage: BCRunAs UserName Domain Password CWD Cmdline
//
strCmd = strPath + '\\BCRunAs.exe ' + strUser + ' ' +
strDomain + ' "' + objOpts.strPassword + '" "';
}
strCmd += 'cmd.exe /K ' + strPath + "\\RegisterMTScript.cmd " +
g_strLocalHost;
if (!fLocal)
{
strCmd += '"';
}
objRemote.RemoteExecuteCmd(strCmd, strPath);
// Do not write any more status after this point -- the remote machine should do it now.
}
catch(ex)
{
fSuccess = false;
objOpts.aMachines[i].WriteStatusInfo("FAILED " + ex);
}
}
if (! CheckStatus(objOpts) )
fSuccess = false;
return fSuccess;
}
function CheckStatus(objOpts)
{
var i;
var fTerminalState;
var strStatus;
var aStatus;
var aState = new Array()
var fChanged;
LogMsg("");
LogMsg("Current status on the remote machines...(Press Ctrl-C to quit)");
do
{
fTerminalState = true;
fChanged = false;
for(i = 0; i < objOpts.aMachines.length;++i)
{
strStatus = objOpts.aMachines[i].ReadStatusInfo();
aStatus = strStatus.split(" ");
if (aStatus.length == 0 || aStatus[0] != 'OK' && aStatus[0] != 'FAILED')
fTerminalState = false;
if (aState[i] == null || aState[i] != strStatus)
{
aState[i] = strStatus;
fChanged = true;
}
}
if (fChanged)
{
for(i = 0; i < objOpts.aMachines.length;++i)
LogMsg(objOpts.aMachines[i].strName + ": " + aState[i]);
if (!fTerminalState)
LogMsg("Waiting...");
LogMsg("");
}
if (!fTerminalState)
WScript.Sleep(1000);
} while(!fTerminalState);
}
// TerminateMTScript(objRemote, objRegistry) //
// //
// Using WMI, terminate processes which may be involved //
// in a build. This is neccessary before a BC upgrade can happen. //
// Also, remote "mtscript.exe" to prevent it getting restarted //
// prematurely. //
// //
function TerminateMTScript(objRemote, objRegistry)
{
var i;
var fRenamed = false;
var strMTScriptPath = ''
try
{
strMTScriptPath = objRegistry.GetExpandedStringValue(WMIRegistry.prototype.HKCR, "CLSID\\" + CLASSID_MTSCRIPT + "\\LocalServer32", '');
}
catch(ex)
{
}
if (strMTScriptPath != '')
{
if (objRemote.RemoteFileExists(strMTScriptPath + ".UpdateInProgress"))
objRemote.RemoteDeleteFile(strMTScriptPath + ".UpdateInProgress");
if (objRemote.RemoteFileExists(strMTScriptPath) &&
objRemote.RemoteRenameFile(strMTScriptPath, strMTScriptPath + ".UpdateInProgress"))
{
fRenamed = true;
}
}
for(i = 0; i < g_aProcsToKill.length; ++i)
objRemote.RemoteTerminateExe(g_aProcsToKill[i], 1);
objRemote.RemoteTerminateExe("sleep.exe", 0); // If sleep.exe sets ERRORLEVEL != 0, then the remote cmd.exe windows will not close.
if (fRenamed)
{
for( i = 3; i >= 0; --i)
{
try
{
objRemote.RemoteDeleteFile(strMTScriptPath + ".UpdateInProgress");
}
catch(ex)
{
if (i == 0)
throw ex;
WScript.Sleep(500); // It sometimes takes a little while for the remote mtscript.exe to quit.
continue;
}
break;
}
}
return true;
}
// DetermineInstallPoint(objOpts, objRemote, objRegistry) //
// //
// If the user has supplied a destination path, use that. //
// Otherwise if mtscript.exe has previously been registered on the remote machine //
// then install to the same location. //
// Else, report an error. //
function DetermineInstallPoint(objOpts, objRemote, objRegistry)
{
var strMTScriptPath = ''
if (objOpts.strDstDir != '')
return objOpts.strDstDir;
try
{
strMTScriptPath = objRegistry.GetExpandedStringValue(WMIRegistry.prototype.HKCR, "CLSID\\" + CLASSID_MTSCRIPT + "\\LocalServer32", '');
}
catch(ex)
{
}
if (strMTScriptPath != '')
strMTScriptPath = SplitFileName(strMTScriptPath)[0];
else
throw new Error(-1, "-dst must be specified -- mtscript was not previously registered");
return strMTScriptPath;
}
// CopyFiles(objRemote, strDstPath, objOpts) //
// //
// Copy the necessary files to the remote machine. //
// The files are always copied to a "flat" install -- the executables and the scripts //
// and as the same directory level. //
// The files in a daily drop are not flat - the executables and the //
// scripts are in seperate directories. //
function CopyFiles(objRemote, strDstPath, objOpts)
{
var i;
var strSourcePath;
var strDstPathUNC;
var strAltLocation;
strSourcePath = RemoveEndChar(objOpts.strSrcDir, "\\");
strDstPathUNC = RemoveEndChar(strDstPath, "\\");
Trace("Copy files from " + strSourcePath + " to " + strDstPathUNC);
g_objFS.CreateFolder(strDstPathUNC);
strAltLocation = strSourcePath + "\\" + objOpts.strArch;
CopyListOfFiles(g_aCopyBCDistDirScript, g_strMyLocation, null, strDstPathUNC, true);
if (objOpts.nDropNum)
{
LogMsg(" Copying files from drop " + strSourcePath);
CopyListOfFiles(g_aCopyFromScripts, strSourcePath + "\\scripts", null, strDstPathUNC, true);
CopyListOfFiles(g_aCopyBCDistDir, strSourcePath + "\\" + objOpts.strArch + "\\" + objOpts.strExeType, null, strDstPathUNC, true);
CopyListOfFiles(g_aCopyBCDistDirD, strSourcePath + "\\" + objOpts.strArch + "\\" + objOpts.strExeType, null, strDstPathUNC, false);
CopyListOfFiles(g_aCopyFromBin, strSourcePath + "\\" + objOpts.strArch + "\\" + objOpts.strExeType, null, strDstPathUNC, true);
}
else
{
LogMsg(" Copying files from " + strSourcePath);
CopyListOfFiles(g_aCopyFromScripts, strSourcePath, strSourcePath + "\\mtscript", strDstPathUNC, true);
CopyListOfFiles(g_aCopyBCDistDir, strSourcePath, strSourcePath + "\\" + objOpts.strArch, strDstPathUNC, true);
CopyListOfFiles(g_aCopyBCDistDirD, strSourcePath, strSourcePath + "\\" + objOpts.strArch, strDstPathUNC, false);
CopyListOfFiles(g_aCopyFromBin, strSourcePath, strSourcePath + "\\" + objOpts.strArch, strDstPathUNC, true);
}
}
// CopyListOfFiles(aFiles, strSrc, strAltSrc, strDst, fRequired) //
// //
// Copy a list of files. //
// Check for the existance of each file in either the strSrc or strAltSrc path. //
// Copy to the strDst path. //
// If a file does not exist, and fRequired is set, then throw an exception. //
function CopyListOfFiles(aFiles, strSrc, strAltSrc, strDst, fRequired)
{
var i;
for(i = 0; i < aFiles.length; ++i)
{
if (g_objFS.FileExists(strSrc + "\\" + aFiles[i]))
g_objFS.CopyFile(strSrc + "\\" + aFiles[i], strDst + "\\" + aFiles[i]);
else if (strAltSrc && g_objFS.FileExists(strAltSrc + "\\" + aFiles[i]))
g_objFS.CopyFile(strAltSrc + "\\" + aFiles[i], strDst + "\\" + aFiles[i]);
else if (fRequired)
throw new Error(-1, "File not found: " + strSrc + "\\" + aFiles[i]);
}
}
// ResetRegistry(objRegistry, strPath) //
// //
// Reset the registry entries for the script path. //
function ResetRegistry(objRegistry, strPath)
{
objRegistry.CreateKey(WMIRegistry.prototype.HKCU, "Software\\Microsoft\\MTScript\\File Paths");
objRegistry.SetStringValue(WMIRegistry.prototype.HKCU, "Software\\Microsoft\\MTScript\\File Paths", "Script Path", strPath);
objRegistry.SetStringValue(WMIRegistry.prototype.HKCU, "Software\\Microsoft\\MTScript\\File Paths", "Initial Script", "mtscript.js");
}
//*********************************************************************
//*********************************************************************
//*********************************************************************
//*********************************************************************
// Library funtions
// SplitFileName(strPath)
// Return an array of 3 elements, path,filename,extension
// [0] == "C:\path\"
// [1] == "filename"
// [2] == ".ext"
function SplitFileName(strPath)
{
var nDot = strPath.lastIndexOf('.');
var nSlash = strPath.lastIndexOf('\\');
var nColon = strPath.lastIndexOf(':');
if (nDot >= 0 && nDot > nSlash && nDot > nColon)
{
return [strPath.slice(0, nSlash + 1), strPath.slice(nSlash + 1, nDot), strPath.slice(nDot)];
}
// We get here if the file had no extension
if (nSlash >= 2) // do not slice the UNC double \ at the start of a filename.
{
return [strPath.slice(0, nSlash + 1), strPath.slice(nSlash + 1, nDot), ''];
}
return ['', strPath, ''];
}
// RemoveEndChar(str, strChar) //
// //
// If 'strChar' appears as the last character //
// in a string, remove it. //
function RemoveEndChar(str, strChar)
{
var length = str.length;
if (str.charAt(length - 1) == strChar)
str = str.slice(0, length - 1);
return str;
}
function PathToUNC(strMachineName, strPath)
{
return "\\\\" +
strMachineName +
"\\" +
strPath.charAt(0) +
"$" +
strPath.slice(2)
}
function Assert(fOK, msg)
{
if (!fOK)
{
var caller = GetCallerName(null);
LogMsg("ASSERTION FAILED :(" + caller + ") " + msg);
WScript.Quit(0);
}
}
function unevalString(str)
{
var i;
var newstr = '"';
var c;
for(i = 0; i < str.length; ++i)
{
c = str.charAt(i);
switch(c)
{
case'\\':
newstr += "\\\\";
break;
case '"':
newstr += '\\"';
break;
case "'":
newstr += "\\'";
break;
case "\n":
newstr += "\\n";
break;
case "\r":
newstr += "\\r";
break;
case "\t":
newstr += "\\t";
break;
default:
newstr += c;
break;
}
}
return newstr + '"';
}
// Object_ToString() //
// //
// Provide a useful version of conversion //
// from "object" to string - great for dumping //
// objects to the debug log. //
function Object_ToString()
{
var i;
var str = "{";
var strComma = '';
for(i in this)
{
str += strComma + i + ":" + this[i];
strComma = ', ';
}
return str + "}";
}
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;
}
}
if (this.description)
{
var end = this.description.length - 1;
while (this.description.charAt(end) == '\n' || this.description.charAt(end) == '\r')
{
end--;
}
this.description = this.description.slice(0, end+1);
}
for(i in this)
{
str += i + ": " + this[i] + " ";
}
return str + ")";
}
function LogMsg(msg)
{
WScript.Echo(msg);
}
function Trace(msg)
{
if (g_Opts && g_Opts.fVerbose)
WScript.Echo(" TRACE: " + msg);
}
function GetCallerName(cIgnoreCaller)
{
var tokens;
if (cIgnoreCaller == null)
cIgnoreCaller = 0;
++cIgnoreCaller;
var caller = GetCallerName.caller;
while (caller != null && cIgnoreCaller)
{
caller = caller.caller;
--cIgnoreCaller;
}
if (caller != null)
{
tokens = caller.toString().split(/ |\t|\)|,/);
if (tokens.length > 1 && tokens[0] == "function")
{
return tokens[1] + ")";
}
}
return "<undefined>";
}
// class WMIInterface(objLogin, strNameSpace) //
// //
// This class provides an easier to use interface to the WMI //
// functionality. //
// //
// You must provide login information and the WMI namespace //
// you wish to use. //
// //
// RemoteFileExists(strPath) NOTHROW //
// returns true if the given file exists on the remote machine //
// //
// RemoteRenameFile(strFrom, strTo) //
// Renames the given file. //
// Throws on any error. //
// //
// RemoteDeleteFile(strPath) //
// Delete the file. //
// Throws on any error. //
// //
// RemoteTerminateExe(strExeName) //
// Terminates all processes with the given name. //
// Does not throw if the process does not exist. //
// It will throw if the RPC to terminate a process fails. //
// Does not return error status. //
// //
// RemoteExecuteCmd(strCmd, strDirectory) //
// Runs the given command in the specified directory. //
// It will throw if the RPC to start the process fails. //
// Its not possible to retrieve status from the command //
// which is run. //
// //
// RemoteDeleteShare(strShareName) //
// If the named share exists, remove it. //
// Throw on error (except if the error is "not found") //
// //
// RemoteCreateShare(strShareName, strSharePath, strShareComment) //
// Create a share name "strShareName" with the given path and comment. //
// Throw on error (it is an error if strShareName is already shared). //
// //
// RemoteShareExists(strShareName) //
// Returns the shared path, or "" //
// does not throw any errors. //
// //
function WMIInterface(objLogin, strNameSpace)
{
try
{
WMIInterface.prototype.wbemErrNotFound = -2147217406;
WMIInterface.prototype.RemoteFileExists = _WMIInterface_FileExists;
WMIInterface.prototype.RemoteRenameFile = _WMIInterface_RenameFile;
WMIInterface.prototype.RemoteDeleteFile = _WMIInterface_DeleteFile;
WMIInterface.prototype.RemoteTerminateExe = _WMIInterface_TerminateExe;
WMIInterface.prototype.RemoteExecuteCmd = _WMIInterface__ExecuteCMD;
WMIInterface.prototype.RemoteDeleteShare = _WMIInterface__DeleteShare;
WMIInterface.prototype.RemoteCreateShare = _WMIInterface__CreateShare;
WMIInterface.prototype.RemoteShareExists = _WMIInterface__ShareExists;
// Private methods
WMIInterface.prototype._FindFiles = _WMIInterface__FindFiles;
WMIInterface.prototype._FileOperation = _WMIInterface__FileOperation;
if (!strNameSpace || strNameSpace == '')
strNameSpace = "root\\cimv2";
this._strNameSpace = strNameSpace;
this._objLogin = objLogin;
this._objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
this._objService = this._objLocator.ConnectServer(this._objLogin.strMachine, this._strNameSpace, this._objLogin.strUser, this._objLogin.strPassword);
this._objService.Security_.impersonationlevel = 3
}
catch(ex)
{
LogMsg("WMIInterface logon failed " + ex);
throw ex;
}
}
function _WMIInterface__FindFiles(strPattern)
{
var objFileSet = this._objService.ExecQuery('Select * from CIM_DataFile Where name=' + unevalString(strPattern));
if (!objFileSet.Count)
throw new Error(-1, "File not found: " + strPattern);
return objFileSet;
}
function _WMIInterface__FileOperation(strPattern, strOperation, objInArgs)
{
try
{
var objFileSet = this._FindFiles(strPattern);
var enumSet = new Enumerator(objFileSet);
for (; !enumSet.atEnd(); enumSet.moveNext())
{
Trace("remote " + strOperation + " " + (objInArgs ? objInArgs : ''));
var objOut = CallMethod(enumSet.item(), strOperation, objInArgs);
break;
}
}
catch(ex)
{
ex.description = strOperation + '(' + strPattern + ')' + " Failed, " + ex.description;
throw ex;
}
return true;
}
function _WMIInterface_FileExists(strName)
{
try
{
var objFileSet = this._objService.ExecQuery('Select * from CIM_DataFile Where name=' + unevalString(strName));
if (objFileSet.Count)
return true;
}
catch(ex)
{
}
Trace("RemoteFileExists: not found " + strName);
return false;
}
function _WMIInterface_RenameFile(strFrom, strTo)
{
return this._FileOperation(strFrom, "Rename", {FileName:strTo});
}
function _WMIInterface_DeleteFile(strName)
{
return this._FileOperation(strName, "Delete");
}
function _WMIInterface_TerminateExe(strName, nExitCode)
{
var setQueryResults = this._objService.ExecQuery("Select Name,ProcessId From Win32_Process");
var enumSet = new Enumerator(setQueryResults);
var nCount = 0;
for( ; !enumSet.atEnd(); enumSet.moveNext())
{
var item = enumSet.item();
if (item.Name == strName)
{
var outParam = CallMethod(item, "Terminate", {Reason:nExitCode}); // Reason will be the return code.
Trace("Killed " + item.Name + " pid = " + item.ProcessId);
nCount++;
}
}
if (!nCount)
Trace("Cannot terminate process " + strName + ": not found");
}
function _WMIInterface__ExecuteCMD(strCmd, strDir)
{
try
{
Trace("Executing :" + strCmd);
var objInstance = this._objService.Get("Win32_Process");
var outParam = CallMethod(objInstance, "Create",
{
CommandLine:strCmd,
CurrentDirectory:strDir
});
//EnumerateSetOfProperties("outParam properties", outParam.Properties_);
Trace("ExecuteCMD " + strCmd + ", pid = " + outParam.ProcessId);
}
catch(ex)
{
ex.description = "ExecuteCMD " + strCmd + " failed " + ex.description;
throw ex;
}
}
function _WMIInterface__DeleteShare(strShareName)
{
try
{
var objInstance = this._objService.Get("Win32_Share='" + strShareName + "'");
Trace("DeleteShare " + objInstance.Name + "," + objInstance.Path);
CallMethod(objInstance, "Delete");
}
catch(ex)
{
if (ex.number != this.wbemErrNotFound)
{
ex.description = "DeleteShare " + strShareName + " failed " + ex.description;
throw ex;
}
else
Trace("DeleteShare " + strShareName + " not found");
}
}
function _WMIInterface__ShareExists(strShareName)
{
try
{
var objInstance = this._objService.Get("Win32_Share='" + strShareName + "'");
Trace("ShareExists " + objInstance.Name + "," + objInstance.Path);
return objInstance.Path;
}
catch(ex)
{
if (ex.number != this.wbemErrNotFound)
{
ex.description = "ShareExists " + strShareName + " failed " + ex.description;
throw ex;
}
else
Trace("ShareExists " + strShareName + " not found");
}
return "";
}
function _WMIInterface__CreateShare(strShareName, strSharePath, strShareComment)
{
try
{
var objInstance = this._objService.Get("Win32_Share");
var outParam = CallMethod(
objInstance,
"Create",
{
Description:strShareComment,
Name:strShareName,
Path:strSharePath,
Type:0
});
}
catch(ex)
{
ex.description = "CreateShare " + strShareName + " failed " + ex.description;
throw ex;
}
}
// class WMIRegistry(objLogin) //
// Class to enable remote registry access via WMI //
// //
// This class provides an easier to use interface to the WMI //
// functionality. //
// //
// You must provide login information and the WMI namespace //
// you wish to use. //
// //
// GetExpandedStringValue(hkey, strSubKeyName, strValueName) //
// Retieves the string value for the given registry key. //
// If strValueName == '', then retrieve the default value. //
// //
// If the value is of type REG_EXPAND_SZ, then the returned //
// string will be the expanded value. //
// //
// Throw any errors. //
// //
// SetStringValue(hkey, strSubKeyName, strValueName, strValue) //
// Sets a string value for the given registry key. //
// If strValueName == '', then set the default value. //
// Throw any errors. //
// //
// CreateKey(hkey, strSubKeyName) //
// Create the specified registry key. //
// Multiple levels of keys can be created at once. //
// It is not an error to create a key which already exists. //
// //
// Throw any errors. //
function WMIRegistry(objLogin)
{
try
{
WMIRegistry.prototype.HKCR = 0x80000000; // Required by StdRegProv
WMIRegistry.prototype.HKCU = 0x80000001; // Required by StdRegProv
WMIRegistry.prototype.GetExpandedStringValue = _WMIRegistry_GetExpandedStringValue;
WMIRegistry.prototype.SetStringValue = _WMIRegistry_SetStringValue;
WMIRegistry.prototype.CreateKey = _WMIRegistry_CreateKey;
this._objRemote = new WMIInterface(objLogin, "root\\default");
this._objInstance = this._objRemote._objService.Get("StdRegProv");
}
catch(ex)
{
LogMsg("WMIRegistry failed " + ex);
throw ex;
}
}
function _WMIRegistry_GetExpandedStringValue(hkey, strSubKeyName, strValueName)
{
try
{
var outParam = CallMethod(this._objInstance, "GetExpandedStringValue", {hDefKey:hkey, sSubKeyName:strSubKeyName, sValueName:strValueName});
return outParam.sValue;
}
catch(ex)
{
ex.description = "GetExpandedStringValue failed ('" + strSubKeyName + "', '" + strValueName + "'): " + ex.description;
throw ex;
}
}
function _WMIRegistry_SetStringValue(hkey, strSubKeyName, strValueName, strValue)
{
try
{
var outParam = CallMethod(this._objInstance, "SetStringValue", {hDefKey:hkey, sSubKeyName:strSubKeyName, sValueName:strValueName, sValue:strValue});
// outParam.ReturnValue == 0;
}
catch(ex)
{
ex.description = "SetStringValue failed ('" + strSubKeyName + "', '" + strValueName + "'): " + ex.description;
throw ex;
}
}
function _WMIRegistry_CreateKey(hkey, strSubKeyName)
{
try
{
var outParam = CallMethod(this._objInstance, "CreateKey", {hDefKey:hkey, sSubKeyName:strSubKeyName});
}
catch(ex)
{
ex.description = "CreateKey failed ('" + strSubKeyName + "', '" + strValueName + "'): " + ex.description;
throw ex;
}
}
// FileSystemObject() //
// //
// Provide enhanced file system access. //
// The primary functionaly here is to provide better error //
// reporting. //
function FileSystemObject()
{
if (!FileSystemObject.prototype.objFS)
{
FileSystemObject.prototype.objFS = new ActiveXObject("Scripting.FileSystemObject");
FileSystemObject.prototype.FileExists = _FileSystemObject_FileExists;
FileSystemObject.prototype.FolderExists = _FileSystemObject_FolderExists;
FileSystemObject.prototype.CreateFolder = _FileSystemObject_CreateFolder;
FileSystemObject.prototype.DeleteFile = _FileSystemObject_DeleteFile;
FileSystemObject.prototype.DeleteFolder = _FileSystemObject_DeleteFolder;
FileSystemObject.prototype.MoveFolder = _FileSystemObject_MoveFolder;
FileSystemObject.prototype.CopyFolder = _FileSystemObject_CopyFolder;
FileSystemObject.prototype.CopyFile = _FileSystemObject_CopyFile;
FileSystemObject.prototype.CreateTextFile = _FileSystemObject_CreateTextFile;
FileSystemObject.prototype.OpenTextFile = _FileSystemObject_OpenTextFile;
}
}
function _FileSystemObject_FileExists(str)
{
try
{
var fRet = this.objFS.FileExists(str);
Trace("FileExists('" + str + "') = " + fRet);
return fRet;
}
catch(ex)
{
ex.description = "FileExists('" + str + "') failed: " + ex.description;
throw ex;
}
}
function _FileSystemObject_FolderExists(str)
{
try
{
var fRet = this.objFS.FolderExists(str);
Trace("FolderExists('" + str + "') = " + fRet);
return fRet;
}
catch(ex)
{
Trace("FolderExists('" + str + "') failed: " + ex);
return false;
}
}
function _FileSystemObject_CreateFolder(str)
{
try
{
if (!this.FolderExists(str))
this.objFS.CreateFolder(str);
}
catch(ex)
{
ex.description = "CreateFolder('" + str + "') failed: " + ex.description;
throw ex;
}
}
function _FileSystemObject_DeleteFile(str)
{
try
{
Trace("DeleteFile '" + str + "'");
this.objFS.DeleteFile(str, true);
}
catch(ex)
{
ex.description = "DeleteFile(" + str + ") failed " + ex.description;
throw ex;
}
}
function _FileSystemObject_DeleteFolder(str)
{
try
{
Trace("DeleteFolder '" + str + "'");
this.objFS.DeleteFolder(str, true);
}
catch(ex)
{
ex.description = "DeleteFolder('" + str + "' failed: " + ex.description;
throw ex;
}
}
function _FileSystemObject_MoveFolder(str, strDst)
{
try
{
Trace("MoveFolder '" + str + "', '" + strDst + "'");
this.objFS.MoveFolder(str, strDst);
}
catch(ex)
{
ex.description = "MoveFolder('" + str + "', '" + strDst + "' failed: " + ex.description;
throw ex;
}
}
function _FileSystemObject_CreateTextFile(strFileName, fOverwrite)
{
do
{
Trace("CreateTextFile '" + strFileName + "'");
try
{
return this.objFS.CreateTextFile(strFileName, fOverwrite);
}
catch(ex)
{
if (fOverwrite && this.FileExists(strFileName))
{
Trace(" CreateTextFile: Attempt to delete " + strFileName);
this.DeleteFile(strFileName);
continue;
}
ex.description = "CreateTextFile('" + strFileName + "' failed: " + ex.description;
throw ex;
}
} while(true);
}
function _FileSystemObject_OpenTextFile(strFileName)
{
var objFile;
do
{
try
{
objFile = this.objFS.OpenTextFile(strFileName, 1);
Trace("OpenTextFile '" + strFileName + "' success");
return objFile;
}
catch(ex)
{
ex.description = "OpenTextFile('" + strFileName + "' failed: " + ex.description;
throw ex;
}
} while(true);
}
function _FileSystemObject_CopyFile(str, strDst)
{
do
{
Trace("CopyFile '" + str + "', '" + strDst + "'");
try
{
this.objFS.CopyFile(str, strDst, true);
break;
}
catch(ex)
{
if (this.FileExists(strDst))
{
Trace(" CopyFile: Attempt to delete " + strDst);
this.DeleteFile(strDst);
continue;
}
ex.description = "CopyFile('" + str + "', '" + strDst + "' failed: " + ex.description;
throw ex;
}
} while(true);
}
function _FileSystemObject_CopyFolder(str, strDst)
{
var strName;
var folder;
var fc;
try
{
Trace("CopyFolder '" + str + "', '" + strDst + "'");
this.CreateFolder(strDst);
folder = this.objFS.GetFolder(str);
fc = new Enumerator(folder.Files);
for (; !fc.atEnd(); fc.moveNext())
{
strName = String(fc.item());
this.CopyFile(strName, strDst + "\\" + fc.item().Name);
}
fc = new Enumerator(folder.SubFolders);
for (; !fc.atEnd(); fc.moveNext())
{
strName = String(fc.item());
this.CopyFolder(strName, strDst + "\\" + fc.item().Name);
}
}
catch(ex)
{
Trace("CopyFolder('" + str + "', '" + strDst + "' failed: " + ex);
throw ex;
}
}
function MachineInfo(strName)
{
this.strName = strName;
this.strStatusFile = g_strShareDir + "\\" + strName + ".txt";
this.fDisabledWriteStatus = false;
MachineInfo.prototype.ReadStatusInfo = _MachineInfo_ReadStatusInfo;
MachineInfo.prototype.WriteStatusInfo = _MachineInfo_WriteStatusInfo;
MachineInfo.prototype.DisableWriteStatusInfo = _MachineInfo_DisableWriteStatusInfo;
}
function _MachineInfo_DisableWriteStatusInfo()
{
this.fDisabledWriteStatus = true;
}
function _MachineInfo_ReadStatusInfo(strText)
{
var strText;
var objFile;
try
{
objFile = g_objFS.OpenTextFile(this.strStatusFile);
strText = objFile.ReadLine();
objFile.Close();
}
catch(ex)
{
strText = "cannot read status file";
}
return strText;
}
function _MachineInfo_WriteStatusInfo(strText)
{
var objFile;
try
{
Trace("WriteStatusInfo(" + strText + ") for " + this.strName);
if (this.fDisabledWriteStatus)
{
LogMsg("Error: Attempting to write status to " + this.strName + " after disabling");
}
else
{
objFile = g_objFS.CreateTextFile(this.strStatusFile, true);
objFile.WriteLine(strText);
objFile.Close();
}
}
catch(ex)
{
LogMsg("WriteStatusInfo(" + strText + ") for " + this.strName + " failed: " + ex);
}
}
//*********************************************************************
//*********************************************************************
// CallMethod(objInstance, strMethodName, hParameters) //
// //
// Call a method on the given object, with the supplied //
// named parameters. //
// //
// Throw if the method returns a non-zero ReturnValue. //
// Else return the outParams. //
function CallMethod(objInstance, strMethodName, hParameters)
{
try
{
Trace("CallMethod " + strMethodName + " " + (hParameters ? hParameters : ''));
var objMethod = objInstance.Methods_(strMethodName);
var inParams;
var outParam;
if (hParameters)
{
if (objMethod.inParameters)
inParams = objMethod.inParameters.SpawnInstance_();
}
var strParamName;
if (hParameters)
{
for(strParamName in hParameters)
inParams[strParamName] = hParameters[strParamName];
outParam = objInstance.ExecMethod_(strMethodName, inParams);
}
else
outParam = objInstance.ExecMethod_(strMethodName);
}
catch(ex)
{
ex.description = "CallMethod " + strMethodName + (hParameters ? hParameters : '()') + " failed " + ex.description;
throw ex;
}
if (outParam.ReturnValue != 0)
throw new Error(outParam.ReturnValue, "Method " + strMethodName + " failed");
return outParam;
}
function EnumerateSetOfProperties(strSetName, SWBemSet, strIndent)
{
var fPrint = false;
if (!strIndent)
{
strIndent = '';
fPrint = true;
}
var strMsg = strIndent + strSetName + "+\n";
strIndent += " ";
try
{
var enumSet = new Enumerator(SWBemSet);
for( ; !enumSet.atEnd(); enumSet.moveNext())
{
var item = enumSet.item();
if (item.Properties_ == null)
{
if (item.Name != "Name")
strMsg += strIndent + item.Name + " = " + item.Value + "\n";
}
else
{
strMsg += EnumerateSetOfProperties(item.Name, item.Properties_, strIndent);
}
}
if (fPrint)
LogMsg(strMsg);
}
catch(ex)
{
if (strIndent == " " && SWBemSet.Properties_ != null)
return EnumerateSetOfProperties(strSetName, SWBemSet.Properties_);
LogMsg("ERROR: " + strSetName + " " + ex);
}
return strMsg;
}
Copy Permalink