1494 lines
53 KiB
JavaScript
1494 lines
53 KiB
JavaScript
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// 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;
|
|
}
|
|
|
|
|