You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1579 lines
56 KiB
1579 lines
56 KiB
/*
|
|
|
|
*/
|
|
|
|
Include('types.js');
|
|
Include('utils.js');
|
|
Include('staticstrings.js');
|
|
Include('MsgQueue.js');
|
|
/*
|
|
This script is invoked by harness.js to provide async
|
|
communications to the slave machines running "slave.js"
|
|
|
|
|
|
Communication between slaveproxy and harness is exclusivly thru
|
|
"messages".
|
|
*/
|
|
|
|
var g_FSObj;
|
|
var g_aPublishedEnlistments = null;
|
|
var g_aFiles = null;
|
|
var g_fUpdatePublicDataPending = false;
|
|
var g_MasterQueue = null;
|
|
var g_cDialogIndex = 0;
|
|
|
|
// If a build machine is reset after a build has completed, its OK to send it the "restart" command.
|
|
var g_fOKToRestartLostMachine = false;
|
|
|
|
var g_strConfigError = 'ConfigError';
|
|
var g_strOK = 'ok';
|
|
var g_strNoEnvTemplate = 'Must set config and environment templates first';
|
|
var g_strStartFailed = "An error occurred in StartRemoteMachine: ";
|
|
var g_strSlaveBusy = "A build server in your distributed build is already busy.";
|
|
var g_strSendCmdRemoteMachine = "SendCmdRemoteMachine failed: ";
|
|
var g_strSendCmdDisconnect = "The connection to the build server no longer exists";
|
|
|
|
var g_SlaveProxyThreadReady = 'SlaveProxyThreadReady';
|
|
var g_SlaveProxyThreadFailed = 'SlaveProxyThreadFailed';
|
|
|
|
// "'Update<machinename>'" is a placeholder. The real name is setup in ScriptMain.
|
|
var g_SlaveProxyWaitFor = ['SlaveProxyThreadExit', 'RebuildWaitArray', 'Update<machinename>'];
|
|
var g_strRemoteMachineName = '';
|
|
var g_MyName = 'slaveproxy';
|
|
var g_aDepotIndex = new Object(); // associate depot name to depot index.
|
|
//var g_fDirectCopy = true; // If true, execute XCOPY directly, instead of with a batch file.
|
|
var g_nBuildPass = 0;
|
|
|
|
function SPLogMsg(msg)
|
|
{
|
|
LogMsg('(' + g_strRemoteMachineName + ') ' + msg, 1);
|
|
}
|
|
|
|
function slaveproxy_js::OnScriptError(strFile, nLine, nChar, strText, sCode, strSource, strDescription)
|
|
{
|
|
return CommonOnScriptError("slaveproxy_js", strFile, nLine, nChar, strText, sCode, strSource, strDescription);
|
|
}
|
|
|
|
function slaveproxy_js::ScriptMain()
|
|
{
|
|
var nEvent;
|
|
var aWaitQueues;
|
|
|
|
g_MasterQueue = GetMsgQueue(ScriptParam);
|
|
|
|
g_MyName = g_MasterQueue.strName;
|
|
g_strRemoteMachineName = g_MyName.split(',')[1];
|
|
|
|
SignalThreadSync(g_SlaveProxyThreadReady);
|
|
CommonVersionCheck(/* $DROPVERSION: */ "V(########) F(!!!!!!!!!!!!!!)" /* $ */);
|
|
|
|
SPLogMsg("Queue name for this thread: " + g_MyName);
|
|
|
|
g_SlaveProxyWaitFor[2] = 'Update' + g_strRemoteMachineName;
|
|
g_FSObj = new ActiveXObject("Scripting.FileSystemObject");
|
|
do
|
|
{
|
|
aWaitQueues = new Array();
|
|
aWaitQueues[0] = g_MasterQueue;
|
|
nEvent = WaitForMultipleQueues(aWaitQueues, g_SlaveProxyWaitFor.toString(), SlaveProxyMsgProc, 0);
|
|
if (nEvent > 0 && nEvent <= g_SlaveProxyWaitFor.length)
|
|
{
|
|
ResetSync(g_SlaveProxyWaitFor[nEvent - 1]);
|
|
if (nEvent == 3)
|
|
{
|
|
RefreshPublicData(false);
|
|
}
|
|
}
|
|
}
|
|
while (nEvent != 1); // While not SlaveProxyThreadExit
|
|
|
|
AbortRemoteMachines();
|
|
SPLogMsg(g_MyName + ' Exit');
|
|
}
|
|
|
|
/*
|
|
slaveproxy_js::OnEventSourceEvent
|
|
Dispatch the event to the appropriate handler.
|
|
*/
|
|
function slaveproxy_js::OnEventSourceEvent(RemoteObj, DispID, cmd, params)
|
|
{
|
|
mach = PrivateData.hRemoteMachine[g_strRemoteMachineName].objRemote;
|
|
if (RemoteObj != mach.obj)
|
|
SPLogMsg("Event from stale remote object? [" + [DispID, cmd, params].toString() + "]");
|
|
|
|
RemoteObj = mach;
|
|
|
|
var vRet = '';
|
|
try
|
|
{
|
|
OnEventSourceEventSlave(RemoteObj, cmd, params)
|
|
}
|
|
catch(ex)
|
|
{
|
|
JAssert(false, "(" + g_strRemoteMachineName + ") " + "an error occurred in OnEventSourceEvent(" + cmd + ") \n" + ex);
|
|
}
|
|
}
|
|
|
|
/*
|
|
OnEventSourceEventSlave
|
|
|
|
Handle NotifyScript() events from slave.js
|
|
*/
|
|
function OnEventSourceEventSlave(RemoteObj, cmd, params)
|
|
{
|
|
var aDepotIdx;
|
|
var i;
|
|
switch(cmd)
|
|
{
|
|
case 'ScriptError':
|
|
NotifyScriptError(RemoteObj, params);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
SlaveProxyMsgProc
|
|
|
|
Handle MsgQueue messages from harness.js
|
|
These messages are of course sent async between harness and slaveproxy.
|
|
They are received and dispatched in slaveproxy_js::ScriptMain().
|
|
*/
|
|
function SlaveProxyMsgProc(queue, msg)
|
|
{
|
|
try
|
|
{
|
|
var newmach;
|
|
var nTracePoint = 0;
|
|
var vRet = g_strOK;
|
|
var params = msg.aArgs;
|
|
var mach;
|
|
|
|
SPLogMsg('(' + g_MyName + ') (g_MasterQueue, msg): ' + params[0]);
|
|
|
|
switch (params[0])
|
|
{
|
|
case 'test':
|
|
SPLogMsg('Recieved a test message. ArgCount=' + params.length + ' arg1 is: ' + params[1]);
|
|
break;
|
|
case 'start':
|
|
newmach = new Machine();
|
|
newmach.strName = g_strRemoteMachineName;
|
|
PublicData.aBuild[0].hMachine[g_strRemoteMachineName] = newmach;
|
|
if (PrivateData.objConfig.Options.fRestart)
|
|
vRet = StartRemoteMachine('restart', true);
|
|
else
|
|
vRet = StartRemoteMachine('start', false);
|
|
break;
|
|
case 'restartcopyfiles':
|
|
vRet = SendCmdRemoteMachine("restartcopyfiles", 0);
|
|
break;
|
|
|
|
case 'abort':
|
|
vRet = AbortRemoteMachines();
|
|
break;
|
|
|
|
case 'copyfilestoslaves':
|
|
SPLogMsg("CopyFilesToSlaves");
|
|
vRet = CopyFilesToSlaves();
|
|
break;
|
|
case 'copyfilestopostbuild':
|
|
vRet = CopyFilesToPostBuild();
|
|
break;
|
|
case 'nextpass':
|
|
++g_nBuildPass;
|
|
SPLogMsg("nextpass counter is " + params[1]);
|
|
vRet = SendCmdRemoteMachine("nextpass", 0);
|
|
break;
|
|
case 'createmergedpublish.log':
|
|
if (PrivateData.objConfig.Options.fCopyPublishedFiles)
|
|
vRet = CreateMergedPublishLog();
|
|
else
|
|
SPLogMsg("Skipping CreateMergedPublishLog - as specified in the config template");
|
|
break;
|
|
case 'ignoreerror':
|
|
case 'remote':
|
|
case 'seval':
|
|
case 'eval':
|
|
vRet = SendCmdRemoteMachine(params[0], params[1]);
|
|
break;
|
|
case 'proxeval':
|
|
try
|
|
{
|
|
SPLogMsg("slaveproxy for " + g_strRemoteMachineName + " executing command " + params[1]);
|
|
vRet = MyEval(params[1]);
|
|
}
|
|
catch(ex)
|
|
{
|
|
vRet = 'Unhandled exception: ' + ex;
|
|
}
|
|
SPLogMsg("proxeval result was: " + vRet);
|
|
break;
|
|
case 'refreshpublicdata':
|
|
RefreshPublicData(true);
|
|
break;
|
|
case 'getspdata':
|
|
getspdata();
|
|
break;
|
|
case 'restarttask': // task id: "machine.nID"
|
|
break;
|
|
default:
|
|
vRet = 'invalid command: ' + cmd;
|
|
break;
|
|
}
|
|
}
|
|
catch(ex)
|
|
{
|
|
SPLogMsg("Exception thrown processing '" + params[0] + "'" + ex);
|
|
//throw(ex);
|
|
}
|
|
return vRet;
|
|
}
|
|
|
|
function SendCmdRemoteMachine(cmd, arg)
|
|
{
|
|
SPLogMsg("Enter");
|
|
var vRet = g_strOK;
|
|
var fRetry = false;
|
|
if (PrivateData.hRemoteMachine[g_strRemoteMachineName] != null)
|
|
{
|
|
SPLogMsg("About to " + cmd + ", arg = " + arg);
|
|
var mach = PrivateData.hRemoteMachine[g_strRemoteMachineName];
|
|
do
|
|
{
|
|
try
|
|
{
|
|
vRet = mach.objRemote.Exec(cmd, arg);
|
|
}
|
|
catch(ex)
|
|
{ // must have already died
|
|
SPLogMsg("Send failed: " + ex);
|
|
fRetry = RestartLostMachine();
|
|
vRet = g_strSendCmdRemoteMachine + cmd;
|
|
}
|
|
} while (fRetry);
|
|
}
|
|
else
|
|
{
|
|
vRet = g_strSendCmdDisconnect;
|
|
}
|
|
SPLogMsg("Exit");
|
|
return vRet;
|
|
}
|
|
|
|
function AbortRemoteMachines()
|
|
{
|
|
SPLogMsg("Enter");
|
|
var vRet = g_strOK;
|
|
|
|
if (PrivateData.hRemoteMachine[g_strRemoteMachineName] != null)
|
|
{
|
|
SPLogMsg("Machine is connected. Aborting...");
|
|
var mach = PrivateData.hRemoteMachine[g_strRemoteMachineName];
|
|
try
|
|
{
|
|
mach.objRemote.Unregister();
|
|
}
|
|
catch(ex)
|
|
{ // must have already died?
|
|
SPLogMsg("Abort failed (UnregisterEventSource): " + ex);
|
|
}
|
|
try
|
|
{
|
|
if (mach.fSetConfig)
|
|
mach.objRemote.Exec('setmode', 'idle');
|
|
delete mach.objRemote;
|
|
}
|
|
catch(ex)
|
|
{ // must have already died
|
|
SPLogMsg("Abort failed: " + ex);
|
|
}
|
|
ResetDepotStatus();
|
|
if (PublicData.aBuild[0].hMachine[g_strRemoteMachineName])
|
|
PublicData.aBuild[0].hMachine[g_strRemoteMachineName].fSuccess = false;
|
|
|
|
delete PrivateData.hRemoteMachine[g_strRemoteMachineName];
|
|
}
|
|
SPLogMsg("Exit");
|
|
return vRet;
|
|
}
|
|
|
|
function ResetDepotStatus()
|
|
{
|
|
var nLocalDepotIdx;
|
|
var Remote_aBuildZero;
|
|
var nDepotIdx;
|
|
|
|
if (!PrivateData.hRemotePublicDataObj[g_strRemoteMachineName])
|
|
return;
|
|
|
|
Remote_aBuildZero = PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0];
|
|
if (!Remote_aBuildZero)
|
|
return;
|
|
|
|
for(nDepotIdx = 0; nDepotIdx < Remote_aBuildZero.aDepot.length; ++nDepotIdx)
|
|
{
|
|
nLocalDepotIdx = g_aDepotIndex[Remote_aBuildZero.aDepot[nDepotIdx].strName.toLowerCase()];
|
|
PublicData.aBuild[0].aDepot[nLocalDepotIdx].strStatus = ABORTED;
|
|
PublicData.aBuild[0].aDepot[nLocalDepotIdx].objUpdateCount.nCount++;
|
|
}
|
|
}
|
|
|
|
function SetDisconnectedDepotStatus(strErrMsg)
|
|
{
|
|
var nLocalDepotIdx;
|
|
var Remote_aBuildZero;
|
|
var nDepotIdx;
|
|
var xTask;
|
|
var item;
|
|
var objMachine;
|
|
|
|
if (!PrivateData.hRemotePublicDataObj[g_strRemoteMachineName])
|
|
return;
|
|
|
|
Remote_aBuildZero = PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0];
|
|
if (!Remote_aBuildZero)
|
|
return;
|
|
|
|
for(nDepotIdx = 0; nDepotIdx < Remote_aBuildZero.aDepot.length; ++nDepotIdx)
|
|
{
|
|
nLocalDepotIdx = g_aDepotIndex[Remote_aBuildZero.aDepot[nDepotIdx].strName.toLowerCase()];
|
|
objDepot = new Depot;
|
|
for(item in Remote_aBuildZero.aDepot[nDepotIdx])
|
|
{
|
|
if (!Remote_aBuildZero.aDepot[nDepotIdx].__isPublicMember(item))
|
|
continue;
|
|
|
|
objDepot[item] = Remote_aBuildZero.aDepot[nDepotIdx][item];
|
|
}
|
|
objDepot.objUpdateCount = new UpdateCount();
|
|
objDepot.aTask = new Array();
|
|
|
|
xTask = new Task();
|
|
xTask.strName = ERROR;
|
|
xTask.strStatus = ERROR;
|
|
xTask.fSuccess = false;
|
|
xTask.strFirstLine = " Connection lost to " + g_strRemoteMachineName + " ";
|
|
xTask.strSecondLine = strErrMsg;
|
|
objDepot.aTask[0] = xTask;
|
|
objDepot.objUpdateCount.nCount = 0;
|
|
objDepot.fDisconnected = true;
|
|
PublicData.aBuild[0].aDepot[nLocalDepotIdx] = objDepot;
|
|
SPLogMsg("Marking " + objDepot.strName + " as disconnected");
|
|
|
|
objMachine = {fSuccess:false, strBuildPassStatus:""};
|
|
if (PublicData.aBuild[0].hMachine[g_strRemoteMachineName])
|
|
objMachine.strBuildPassStatus = PublicData.aBuild[0].hMachine[g_strRemoteMachineName].strBuildPassStatus;
|
|
|
|
PublicData.aBuild[0].hMachine[g_strRemoteMachineName] = objMachine;
|
|
}
|
|
}
|
|
|
|
function CreateErrorDepot(strErrMsg)
|
|
{
|
|
var tmpDepot = new Depot;
|
|
var xTask;
|
|
|
|
tmpDepot.strStatus = ERROR;
|
|
tmpDepot.strMachine = g_strRemoteMachineName;
|
|
tmpDepot.strName = 'root';
|
|
tmpDepot.aTask = new Array();
|
|
xTask = new Task();
|
|
xTask.strName = ERROR;
|
|
xTask.strStatus = ERROR;
|
|
xTask.strFirstLine = " Cannot connect to " + g_strRemoteMachineName + " ";
|
|
xTask.strSecondLine = strErrMsg;
|
|
tmpDepot.aTask[0] = xTask;
|
|
|
|
if (PublicData.aBuild[0].hMachine[g_strRemoteMachineName])
|
|
PublicData.aBuild[0].hMachine[g_strRemoteMachineName].fSuccess = false;
|
|
|
|
UpdatePublicDataDepot(tmpDepot);
|
|
}
|
|
|
|
function RestartLostMachine()
|
|
{
|
|
var vRet;
|
|
var RemoteObj;
|
|
var strTmp;
|
|
var nRetryCount;
|
|
RemoteObj = PrivateData.hRemoteMachine[g_strRemoteMachineName].objRemote;
|
|
if (RemoteObj.fMachineReset)
|
|
{
|
|
if (g_fOKToRestartLostMachine)
|
|
{
|
|
SPLogMsg("ABOUT TO RESTART REMOTE MACHINE");
|
|
vRet = StartRemoteMachine('restart', false);
|
|
// StartRemoteMachine recreates RemoteObj -- we must grab an updated copy.
|
|
RemoteObj = PrivateData.hRemoteMachine[g_strRemoteMachineName].objRemote;
|
|
if (vRet == g_strOK)
|
|
{
|
|
// Wait a little while for the remote machine to get to its completed state.
|
|
nRetryCount = 15;
|
|
if (!Already)
|
|
{
|
|
Already = true;
|
|
throw new Error(-1, "Bogus nogus");
|
|
}
|
|
do
|
|
{
|
|
strTmp = MyEval(newremotemach.objRemote.Exec('getpublic', 'PublicData.strMode'));
|
|
if (strTmp == COMPLETED)
|
|
break;
|
|
|
|
Sleep(500);
|
|
nRetryCount--;
|
|
} while(nRetryCount);
|
|
RemoteObj.fStopTryingToGetPublicData = true;
|
|
SPLogMsg("Restart remote machine successfull, retries=" + nRetryCount);
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
RemoteObj.fStopTryingToGetPublicData = true;
|
|
}
|
|
SPLogMsg("failed fMachineReset = " + RemoteObj.fMachineReset + ", g_fOKToRestartLostMachine = " + g_fOKToRestartLostMachine);
|
|
return false;
|
|
}
|
|
|
|
function StartRemoteMachine(strStart, fReconnectRunningBuild)
|
|
{
|
|
vRet = ConnectToRemoteMachine(strStart, fReconnectRunningBuild);
|
|
if (vRet == g_strOK)
|
|
{
|
|
SPLogMsg("Started machine " + g_strRemoteMachineName + ", now sending message");
|
|
return g_strOK;
|
|
}
|
|
else
|
|
{
|
|
if (vRet == "alreadyset")
|
|
vRet = "machine in use";
|
|
|
|
CreateErrorDepot(vRet);
|
|
ReportError("Starting build", "Cannot " + strStart + " build on machine : " + g_strRemoteMachineName + "\n" + vRet);
|
|
g_MasterQueue.SendMessage('abort', 0);
|
|
return vRet;
|
|
}
|
|
}
|
|
|
|
function ConnectToRemoteMachine(strStart, fReconnectRunningBuild)
|
|
{
|
|
var vRet = g_strOK;
|
|
var newremotemach;
|
|
var strTmp;
|
|
var RemotePublicData;
|
|
try
|
|
{
|
|
newremotemach = new RemoteMachine();
|
|
newremotemach.objRemote = new RemoteWrapper(g_strRemoteMachineName);
|
|
|
|
if (fReconnectRunningBuild)
|
|
{
|
|
strTmp = MyEval(newremotemach.objRemote.Exec('getpublic', 'PublicData.strMode'));
|
|
if (strTmp != 'idle')
|
|
{
|
|
SPLogMsg("Remote machine already busy, same templates?");
|
|
RemotePublicData = MyEval(newremotemach.objRemote.Exec('getpublic', 'root'));
|
|
if (RemotePublicData.aBuild && RemotePublicData.aBuild[0])
|
|
{
|
|
if (RemotePublicData.aBuild[0].strEnvTemplate == PublicData.aBuild[0].strEnvTemplate)
|
|
{
|
|
newremotemach.fSetConfig = true;
|
|
PrivateData.hRemoteMachine[g_strRemoteMachineName] = newremotemach;
|
|
newremotemach.objRemote.Register();
|
|
SPLogMsg("Remote machine env template matches -- no need to restart it");
|
|
return vRet;
|
|
}
|
|
SPLogMsg("Remote templates:" + RemotePublicData.aBuild[0].strConfigTemplate + ", " + RemotePublicData.aBuild[0].strEnvTemplate);
|
|
}
|
|
else
|
|
SPLogMsg("Remote machine is not idle, but aBuild[0] is missing.");
|
|
|
|
SPLogMsg("Remote machine template mismatch -- forcing idle");
|
|
vRet = newremotemach.objRemote.Exec('setmode', 'idle');
|
|
SPLogMsg("Setmode returns " + vRet);
|
|
}
|
|
}
|
|
SPLogMsg('Setconfig on machine');
|
|
|
|
vRet = newremotemach.objRemote.Exec('setstringmap', PrivateData.aStringMap.toString());
|
|
if (vRet != g_strOK)
|
|
return vRet;
|
|
|
|
vRet = newremotemach.objRemote.Exec('setconfig', PublicData.aBuild[0].strConfigTemplate);
|
|
if (vRet == g_strOK)
|
|
{
|
|
// If setconfig returns OK, then we know we have the undivided attention of the
|
|
// slave machine. If setconfig does not return OK, then the remote machine
|
|
// may already be busy with some other build. In this case it would be really
|
|
// bad for us to issue a 'setmode idle' command.
|
|
newremotemach.fSetConfig = true;
|
|
strTmp = MyEval(newremotemach.objRemote.Exec('getpublic', 'PublicData.strMode'));
|
|
if (strTmp != 'idle')
|
|
vRet = g_strSlaveBusy + " '" + g_strRemoteMachineName + "' (" + strTmp + ")";
|
|
}
|
|
|
|
if (vRet == g_strOK)
|
|
{
|
|
vRet = newremotemach.objRemote.Exec('setenv', PublicData.aBuild[0].strEnvTemplate);
|
|
SPLogMsg(' setenv returned: ' + vRet);
|
|
}
|
|
if (vRet == g_strOK)
|
|
{
|
|
vRet = newremotemach.objRemote.Exec('setmode', 'slave');
|
|
SPLogMsg(' setmode returned: ' + vRet);
|
|
}
|
|
if (vRet == g_strOK)
|
|
{
|
|
vRet = newremotemach.objRemote.Exec(strStart, 0);
|
|
SPLogMsg(' ' + strStart + ' returned: ' + vRet);
|
|
}
|
|
if (vRet == g_strOK)
|
|
{
|
|
PrivateData.hRemoteMachine[g_strRemoteMachineName] = newremotemach;
|
|
newremotemach.objRemote.Register();
|
|
SPLogMsg("Started machine " + g_strRemoteMachineName);
|
|
}
|
|
}
|
|
catch(ex)
|
|
{
|
|
// Oddly, if the remote machine is not found, "ex" has a helpful error message.
|
|
// However, if the remote machine is found, has mtscript.exe registered, but mtscript.exe
|
|
// is unable to run (somebody deleted it perhaps), then "ex" has only "number" set
|
|
// to the value -2147024894.
|
|
if (ex.description == null || ex.description.length == 0) //ex.number == -2147024894) // Mtscript.exe cannot run
|
|
{
|
|
vRet = "An error occurred connecting to mtscript.exe on machine " + g_strRemoteMachineName + ". Error is " + ex.number;
|
|
SPLogMsg(vRet + "\n" + ex);
|
|
}
|
|
else
|
|
{
|
|
vRet = g_strStartFailed + ex;
|
|
SPLogMsg(vRet);
|
|
}
|
|
}
|
|
return vRet;
|
|
}
|
|
|
|
/*
|
|
UpdatePublicDataDepot()
|
|
|
|
Update the local copy of depot public data from our
|
|
remote machine.
|
|
*/
|
|
function UpdatePublicDataDepot(objDepot)
|
|
{
|
|
var nLocalDepotIdx;
|
|
|
|
nLocalDepotIdx = g_aDepotIndex[objDepot.strName.toLowerCase()];
|
|
//JAssert(nLocalDepotIdx != null, "(" + g_strRemoteMachineName + ") " + "Unknown depot! " + objDepot.strName);
|
|
if (nLocalDepotIdx == null)
|
|
{ // This happens when there is an "error" depot - a depot with a bad enlistment directory.
|
|
SPLogMsg("Unknown depot " + objDepot.strName + " - assign new index");
|
|
TakeThreadLock('NewDepot');
|
|
try
|
|
{
|
|
nLocalDepotIdx = PublicData.aBuild[0].aDepot.length;
|
|
PublicData.aBuild[0].aDepot[nLocalDepotIdx] = null; // Extend the length of the array
|
|
}
|
|
catch(ex)
|
|
{
|
|
SPLogMsg("Exception while creating a new depot, " + ex);
|
|
}
|
|
ReleaseThreadLock('NewDepot');
|
|
|
|
g_aDepotIndex[objDepot.strName.toLowerCase()] = nLocalDepotIdx;
|
|
|
|
SPLogMsg("New index is " + nLocalDepotIdx + " new length is " + PublicData.aBuild[0].aDepot.length);
|
|
}
|
|
|
|
JAssert(!PublicData.aBuild[0].aDepot[nLocalDepotIdx] ||
|
|
PublicData.aBuild[0].aDepot[nLocalDepotIdx].strName == objDepot.strName,
|
|
"Overwriting another depot in the master depot list!");
|
|
|
|
PublicData.aBuild[0].aDepot[nLocalDepotIdx] = objDepot;
|
|
}
|
|
|
|
/*
|
|
SmartGetPublic(fForceRoot)
|
|
|
|
Refresh our copy of the remote machines PublicData.
|
|
If we have never retrieved status from the remote machine
|
|
then get a full copy.
|
|
|
|
Otherwise do a "smart" update - ask for a status update
|
|
on just the depots that have changed.
|
|
|
|
Always get fresh copies of elapsed time and error dialog.
|
|
*/
|
|
function SmartGetPublic(fForceRoot)
|
|
{
|
|
var objTracePoint = { fnName:'SmartGetPublic', nTracePoint:0 };
|
|
var fRetry;
|
|
var RemoteObj;
|
|
|
|
do
|
|
{
|
|
try
|
|
{
|
|
fRetry = false;
|
|
RemoteObj = PrivateData.hRemoteMachine[g_strRemoteMachineName].objRemote;
|
|
if (RemoteObj.fMachineReset && !g_fOKToRestartLostMachine)
|
|
return false;
|
|
if (RemoteObj.fStopTryingToGetPublicData)
|
|
return true;
|
|
|
|
SmartGetPublicWorker(objTracePoint, RemoteObj, fForceRoot);
|
|
if (RemoteObj.fMachineReset)
|
|
SPLogMsg("SmartGetPublic should have failed -- machine is reset");
|
|
return true;
|
|
}
|
|
catch(ex)
|
|
{
|
|
SPLogMsg("SmartGetPublic() failed, TracePoint = " + objTracePoint.nTracePoint + ", " + ex);
|
|
return RestartLostMachine();
|
|
}
|
|
} while (fRetry);
|
|
SPLogMsg("failed to get public data");
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
GetPublicRoot(objTracePoint, RemoteObj)
|
|
|
|
Get a full copy of the remote machines PublicData.
|
|
Prune the object of the parts we are not interested in.
|
|
Place it in our own PublicData.
|
|
*/
|
|
function GetPublicRoot(objTracePoint, RemoteObj)
|
|
{
|
|
var objRemotePublicData;
|
|
|
|
objTracePoint.fnName = 'GetPublicRoot';
|
|
objRemotePublicData = RemoteObj.Exec('getpublic', 'root');
|
|
objRemotePublicData = PrivateData.objUtil.fnMyEval(objRemotePublicData);
|
|
objTracePoint.nTracePoint = 1;
|
|
if (objRemotePublicData != null)
|
|
{
|
|
objTracePoint.nTracePoint = 2;
|
|
delete objRemotePublicData.nDataVersion;
|
|
delete objRemotePublicData.strStatus;
|
|
delete objRemotePublicData.strMode;
|
|
objTracePoint.nTracePoint = 6;
|
|
if (objRemotePublicData.aBuild != null && objRemotePublicData.aBuild[0] != null)
|
|
{
|
|
objTracePoint.nTracePoint = 7;
|
|
if (objRemotePublicData.aBuild[0].hMachine[g_strRemoteMachineName] != null)
|
|
{
|
|
objTracePoint.nTracePoint = 8;
|
|
delete objRemotePublicData.aBuild[0].hMachine[g_strRemoteMachineName].strName;
|
|
delete objRemotePublicData.aBuild[0].hMachine[g_strRemoteMachineName].strStatus;
|
|
delete objRemotePublicData.aBuild[0].hMachine[g_strRemoteMachineName].strLog
|
|
delete objRemotePublicData.aBuild[0].hMachine[g_strRemoteMachineName].aEnlistment;
|
|
objTracePoint.nTracePoint = 9;
|
|
}
|
|
else
|
|
SPLogMsg("hMachine IS null");
|
|
|
|
}
|
|
PrivateData.hRemotePublicDataObj[g_strRemoteMachineName] = objRemotePublicData;
|
|
}
|
|
}
|
|
|
|
function SmartGetPublicWorker(objTracePoint, RemoteObj, fForceRoot)
|
|
{
|
|
objTracePoint.fnName = 'SmartGetPublicWorker';
|
|
if (fForceRoot ||
|
|
PrivateData.hRemotePublicDataObj[g_strRemoteMachineName] == null ||
|
|
PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0].hMachine == null ||
|
|
PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0].hMachine[g_strRemoteMachineName] == null)
|
|
{
|
|
GetPublicRoot(objTracePoint, RemoteObj);
|
|
}
|
|
else
|
|
{
|
|
var str = "";
|
|
var comma = "";
|
|
var i;
|
|
var aDepot;
|
|
if (PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0] != null)
|
|
{
|
|
aDepot = PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0].aDepot;
|
|
if (aDepot != null)
|
|
{
|
|
for(i = 0 ; i < aDepot.length; ++i)
|
|
{
|
|
/*
|
|
fDisconnected is never explicitly reset.
|
|
Once the connection to the remote machine is reestablished
|
|
the Depot object is simply replaced with the depot object from the
|
|
remote machine. Thus, "fDisconnected" disappears entirely.
|
|
|
|
Below, if "fDisconneced" is true we do not list this depot
|
|
in the list sent to "getdepotupdate". This forces getdepotupdate
|
|
to return status for this depot, since as far as it knows
|
|
we do not have any status information for this depot.
|
|
*/
|
|
if (aDepot[i].fDisconnected != true)
|
|
{
|
|
strDepotID = aDepot[i].strMachine + "," + aDepot[i].strName;
|
|
str += comma + "'" + strDepotID + "'" + ":" + aDepot[i].objUpdateCount.nCount;
|
|
comma = ",";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
str = "var _o0 = {" + str + " }; _o0";
|
|
objTracePoint.nTracePoint = 1;
|
|
var aUpdateDepot = RemoteObj.Exec('getdepotupdate', str);
|
|
objTracePoint.nTracePoint = 2;
|
|
aUpdateDepot = PrivateData.objUtil.fnMyEval(aUpdateDepot);
|
|
objTracePoint.nTracePoint = 3;
|
|
for(i = 0; i < aUpdateDepot.length; ++i)
|
|
{
|
|
if (aUpdateDepot[i] != null)
|
|
aDepot[i] = aUpdateDepot[i];
|
|
}
|
|
|
|
var aThingsToFetch =
|
|
[
|
|
'PublicData.aBuild[0].objElapsedTimes',
|
|
'PublicData.objDialog',
|
|
'PublicData.aBuild[0].hMachine["' + g_strRemoteMachineName + '"].strBuildPassStatus',
|
|
'PublicData.aBuild[0].hMachine["' + g_strRemoteMachineName + '"].fSuccess'
|
|
];
|
|
objTracePoint.nTracePoint = 4;
|
|
var obj = RemoteObj.Exec('getpublic', '[' + aThingsToFetch.toString() + ']');
|
|
objTracePoint.nTracePoint = 5;
|
|
var obj = PrivateData.objUtil.fnMyEval(obj);
|
|
objTracePoint.nTracePoint = 6;
|
|
|
|
PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0].objElapsedTimes = obj[0];
|
|
objTracePoint.nTracePoint = 7;
|
|
PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].objDialog = obj[1];
|
|
objTracePoint.nTracePoint = 8;
|
|
if (PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0].hMachine != null &&
|
|
PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0].hMachine[g_strRemoteMachineName] != null)
|
|
{
|
|
PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0].hMachine[g_strRemoteMachineName].strBuildPassStatus = obj[2];
|
|
PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0].hMachine[g_strRemoteMachineName].fSuccess = obj[3];
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
RefreshPublicData()
|
|
We have received notification that the remote machine public
|
|
data has changed. We need to grab a copy and place it in our
|
|
own public data.
|
|
|
|
The depot status information can be copied in its entirty, with
|
|
just a simple mapping of depot indices.
|
|
Each slave machine knows only about the depots its building.
|
|
(From enviro_templates\foo_env.xml)
|
|
The build machine (this machine) knows about all the depots
|
|
being built.
|
|
*/
|
|
function RefreshPublicData(fForceRoot)
|
|
{
|
|
var iRemoteDepot;
|
|
var dlg;
|
|
var Remote_aBuildZero;
|
|
var nTracePoint = 0;
|
|
|
|
try // BUGBUG remove the nTracePoint stuff when the cause of the exception here is determined.
|
|
{
|
|
if (PrivateData.hRemoteMachine[g_strRemoteMachineName] == null)
|
|
return;
|
|
nTracePoint = 1;
|
|
if (!SmartGetPublic(fForceRoot))
|
|
{
|
|
return;
|
|
}
|
|
var RemoteObj = PrivateData.hRemoteMachine[g_strRemoteMachineName].objRemote;
|
|
nTracePoint = 2;
|
|
if (PrivateData.hRemotePublicDataObj[g_strRemoteMachineName] != null)
|
|
{
|
|
delete PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].hRemotePublicDataObj;
|
|
|
|
// Before we update the depot info, first check to see that
|
|
// the remote machine has created aBuild[0], and that we have setup hMachine.
|
|
if (PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0] != null && PublicData.aBuild[0].hMachine[g_strRemoteMachineName] != null)
|
|
{
|
|
nTracePoint = 3;
|
|
Remote_aBuildZero = PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].aBuild[0];
|
|
for (iRemoteDepot = 0; iRemoteDepot < Remote_aBuildZero.aDepot.length; ++iRemoteDepot)
|
|
UpdatePublicDataDepot(Remote_aBuildZero.aDepot[iRemoteDepot]);
|
|
// now copy the status info stored in hMachine
|
|
nTracePoint = 4;
|
|
if (Remote_aBuildZero.hMachine[g_strRemoteMachineName] != null)
|
|
{
|
|
PublicData.aBuild[0].hMachine[g_strRemoteMachineName] = Remote_aBuildZero.hMachine[g_strRemoteMachineName];
|
|
}
|
|
nTracePoint = 5;
|
|
MergeDates(PublicData, PrivateData.hRemotePublicDataObj[g_strRemoteMachineName]);
|
|
nTracePoint = 6;
|
|
CheckBuildStatus();
|
|
nTracePoint = 7;
|
|
}
|
|
nTracePoint = 8;
|
|
|
|
if (PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].objDialog != null)
|
|
{
|
|
dlg = PrivateData.hRemotePublicDataObj[g_strRemoteMachineName].objDialog;
|
|
nTracePoint = 9;
|
|
DisplayDialog(dlg);
|
|
}
|
|
}
|
|
}
|
|
catch(ex)
|
|
{
|
|
SPLogMsg("RefreshPublicData caught an exception nTracePoint=" + nTracePoint + " " + ex);
|
|
}
|
|
}
|
|
|
|
function ReportError(strTitle, strMsg)
|
|
{
|
|
dlg = new Dialog();
|
|
dlg.fShowDialog = true;
|
|
dlg.cDialogIndex = 0;
|
|
dlg.strTitle = strTitle;
|
|
dlg.strMessage = strMsg;
|
|
dlg.aBtnText[0] = "OK";
|
|
g_MasterQueue.SendMessage('displaydialog',dlg);
|
|
}
|
|
|
|
function MergeDates(pd, rpd)
|
|
{
|
|
try
|
|
{
|
|
var objElapsedTimes;
|
|
var objRemoteElapsed;
|
|
var aDateMembers;
|
|
var i = -1;
|
|
var dlg;
|
|
var fLocked = false;
|
|
|
|
if (pd.aBuild[0].objElapsedTimes && rpd.aBuild[0].objElapsedTimes)
|
|
{
|
|
objElapsedTimes = pd.aBuild[0].objElapsedTimes;
|
|
objRemoteElapsed = rpd.aBuild[0].objElapsedTimes;
|
|
aDateMembers = ['dateScorch', 'dateSync', 'dateBuild', 'dateCopyFiles', 'datePost'];
|
|
TakeThreadLock("MergeDates");
|
|
fLocked = true;
|
|
for(i = 0; i < aDateMembers.length; ++i)
|
|
{
|
|
objElapsedTimes[aDateMembers[i] + "Start"] = DateCmp(objElapsedTimes, objRemoteElapsed, aDateMembers[i] + "Start", Math.min);
|
|
objElapsedTimes[aDateMembers[i] + "Finish"] = DateCmp(objElapsedTimes, objRemoteElapsed, aDateMembers[i] + "Finish", Math.max);
|
|
}
|
|
ReleaseThreadLock("MergeDates");
|
|
fLocked = false;
|
|
}
|
|
}
|
|
catch(ex)
|
|
{
|
|
JAssert(false, "(" + g_strRemoteMachineName + ") " + "MergeDates crashed, i = " + i + ", " + ex);
|
|
if (fLocked)
|
|
ReleaseThreadLock("MergeDates");
|
|
}
|
|
}
|
|
|
|
// Compare 2 dates from PublicData.
|
|
// Paramaters are: the 2 public data objElapsedTimes objects,
|
|
// the member name, and a comparision function (min or max).
|
|
//
|
|
// An empty time (null) is greater than any other time because an unspecified
|
|
// time is considered to mean "now". A value of 'unset' means the value has
|
|
// never been touched. For obj1, 'unset' is always replaced with the value
|
|
// of obj2, and for obj2 'unset' is treated the same as null.
|
|
//
|
|
// Boolean Matrix: (* = don't care, null = null or empty)
|
|
//
|
|
// fnCmp = Math.min: fnCmp = Math.max:
|
|
//
|
|
// obj1 obj2 result obj1 obj2 result
|
|
// --------------------------- --------------------------
|
|
// "unset" * obj2 "unset" * obj2
|
|
// * "unset" same as obj2=null * "unset" same as obj2=null
|
|
// null null null null null null
|
|
// null date date ####-> null date null <-####
|
|
// date null date date null null
|
|
// date1 date2 min(date1,date2) date1 date2 max(date1,date2)
|
|
//
|
|
// The above matrix can be accomplished by treating null as a time which is
|
|
// later than all other times (such as the current time or some always future
|
|
// date). Note that "unset" and null must be distiguishable due to the case
|
|
// marked with "####" above.
|
|
//
|
|
function DateCmp(obj1, obj2, member, fnCmp)
|
|
{
|
|
var t1 = obj1[member];
|
|
var t2 = obj2[member];
|
|
|
|
if (t1 == null || t1.length == 0)
|
|
t1 = "December 31 9999 23:59:59 UTC";
|
|
else if (t1 == 'unset')
|
|
return t2;
|
|
|
|
if (t2 == null || t2.length == 0 || t2 == 'unset')
|
|
t2 = "December 31 9999 23:59:59 UTC";
|
|
|
|
var delta = Date.parse(t1) - Date.parse(t2);
|
|
|
|
if (fnCmp(delta, 0) == delta)
|
|
return obj1[member];
|
|
|
|
return obj2[member];
|
|
}
|
|
|
|
function NotifyScriptError(RemoteObj, params)
|
|
{
|
|
var dlg;
|
|
var btn;
|
|
if (params != null)
|
|
{
|
|
dlg = PrivateData.objUtil.fnMyEval(params);
|
|
DisplayDialog(dlg);
|
|
}
|
|
}
|
|
|
|
function DisplayDialog(dlg)
|
|
{
|
|
if (dlg.cDialogIndex > g_cDialogIndex)
|
|
{
|
|
SPLogMsg("*** DisplayDialog " + dlg.cDialogIndex + " " + dlg.strTitle + ", " + dlg.strMessage);
|
|
g_cDialogIndex = dlg.cDialogIndex;
|
|
g_MasterQueue.SendMessage('displaydialog',dlg);
|
|
PrivateData.hRemoteMachine[g_strRemoteMachineName].objRemote.Exec('dialog', 'hide,' + dlg.cDialogIndex);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
Check to see if our slave machine has completed a pass
|
|
and is waiting for the "nextpass" command.
|
|
|
|
If it is waiting, then first publish the files in its
|
|
publish.log, then signal to harness that this slave is
|
|
ready to subscribe and continue to the next pass.
|
|
*/
|
|
function CheckBuildStatus()
|
|
{
|
|
var strPubLog;
|
|
var strStat;
|
|
var nPass;
|
|
var mach;
|
|
|
|
mach = PrivateData.hRemoteMachine[g_strRemoteMachineName];
|
|
|
|
strStat = PublicData.aBuild[0].hMachine[g_strRemoteMachineName].strBuildPassStatus.split(',');
|
|
nPass = strStat[1];
|
|
strStat = strStat[0];
|
|
|
|
switch(strStat)
|
|
{
|
|
case WAIT + SCORCH:
|
|
case WAIT + SYNC:
|
|
break;
|
|
case WAITBEFOREBUILDINGMERGED:
|
|
/*
|
|
First, get the publish.log
|
|
Then, remove build out our list of published files
|
|
and remove duplicates.
|
|
Then, tell slave to publish this list of file and change
|
|
its status to WAITCOPYTOPOSTBUILD
|
|
TODO: The slave currently doesn't actually do the file copies. It oughta.
|
|
*/
|
|
if (g_aPublishedEnlistments != null)
|
|
return;
|
|
SPLogMsg("strBuildPassStatus is " + PublicData.aBuild[0].hMachine[g_strRemoteMachineName].strBuildPassStatus + ", pass is " + g_nBuildPass);
|
|
strPubLog = mach.objRemote.Exec('GetPublishLog', 0);
|
|
g_aPublishedEnlistments = MyEval(strPubLog);
|
|
PreCopyFilesToPostBuild(g_aPublishedEnlistments);
|
|
break;
|
|
case WAITAFTERMERGED:
|
|
strPubLog = mach.objRemote.Exec('GetPublishLog', 0);
|
|
FakeCopyFilesToPostBuild(MyEval(strPubLog));
|
|
break;
|
|
case WAIT + BUILD:
|
|
case WAITCOPYTOPOSTBUILD:
|
|
case WAITNEXT: // impatiently waiting. Lets poke harness again it case it missed something!
|
|
case WAITPHASE:
|
|
break;
|
|
case WAIT + POSTBUILD:
|
|
case WAIT + COPYFILES:
|
|
case BUSY:
|
|
case "":
|
|
break;
|
|
case COMPLETED:
|
|
g_fOKToRestartLostMachine = true;
|
|
break;
|
|
default:
|
|
JAssert(false, "(" + g_strRemoteMachineName + ") " + "CheckBuildStatus failed: unknown status '" + PublicData.aBuild[0].hMachine[g_strRemoteMachineName].strBuildPassStatus + "'");
|
|
break;
|
|
}
|
|
}
|
|
|
|
// FakeCopyFilesToPostBuild()
|
|
// Called after the postbuild machine build mergedcomponents.
|
|
// no file copies need to happen here -- we just need to get the
|
|
// files onto the list of published files so that the other slaves
|
|
// will pick them up during CopyFilesToSlaves
|
|
function FakeCopyFilesToPostBuild(aPublishedEnlistments)
|
|
{
|
|
var aFiles;
|
|
var i;
|
|
for(i = 0; i < aPublishedEnlistments.length; ++i)
|
|
{
|
|
PublishFilesInEnlistment(aPublishedEnlistments[i]);
|
|
}
|
|
RemoveDuplicateFileNames(g_strRemoteMachineName);
|
|
|
|
JAssert(aPublishedEnlistments != null, "(" + g_strRemoteMachineName + ") ");
|
|
if (aPublishedEnlistments)
|
|
{
|
|
aFiles = CreateListOfPublishedFiles(FS_NOTYETCOPIED, FS_COPIEDTOMASTER);
|
|
vRet = SendCmdRemoteMachine("nextpass", 0);
|
|
}
|
|
}
|
|
|
|
// Initiate file copy from the slaves to post build machine
|
|
function PreCopyFilesToPostBuild(aPublishedEnlistments)
|
|
{
|
|
g_aFiles = null;
|
|
|
|
var i;
|
|
for(i = 0; i < aPublishedEnlistments.length; ++i)
|
|
{
|
|
PublishFilesInEnlistment(aPublishedEnlistments[i]);
|
|
}
|
|
RemoveDuplicateFileNames(g_strRemoteMachineName);
|
|
|
|
JAssert(aPublishedEnlistments != null, "(" + g_strRemoteMachineName + ") ");
|
|
if (aPublishedEnlistments)
|
|
{
|
|
g_aFiles = CreateListOfPublishedFiles(FS_NOTYETCOPIED, FS_COPIEDTOMASTER);
|
|
strNewStat = PrivateData.hRemoteMachine[g_strRemoteMachineName].objRemote.Exec('setbuildpassstatus', WAITCOPYTOPOSTBUILD);
|
|
SPLogMsg("setbuildpassstatus to '" + WAITCOPYTOPOSTBUILD + "' returned '" + strNewStat + "'");
|
|
PublicData.aBuild[0].hMachine[g_strRemoteMachineName].strBuildPassStatus = strNewStat;
|
|
}
|
|
}
|
|
|
|
function CopyFilesToPostBuild()
|
|
{
|
|
var strNewStat;
|
|
if (g_aFiles)
|
|
{
|
|
//SPLogMsg("CopyFilesToPostBuild " + PrivateData.objUtil.fnUneval(g_aFiles));
|
|
strNewStat = PrivateData.hRemoteMachine[g_strRemoteMachineName].objRemote.Exec('copyfilestopostbuild', PrivateData.objUtil.fnUneval(g_aFiles));
|
|
PublicData.aBuild[0].hMachine[g_strRemoteMachineName].strBuildPassStatus = strNewStat;
|
|
}
|
|
g_aPublishedEnlistments = null;
|
|
}
|
|
|
|
/*
|
|
Generate a merged publish.log file consisting of all the files published on all of the machines.
|
|
|
|
Publish.log file format is:
|
|
|
|
Full_Path_Of_file Original_File_path FileNameOnly
|
|
|
|
BC does not record "Original_File_path" information from the original publish log files
|
|
so it simply writes placeholder "BC_EmptyColumn" in this column.
|
|
*/
|
|
function CreateMergedPublishLog()
|
|
{
|
|
var strSrcName;
|
|
var strDest;
|
|
var strPostBuildMachineDir ;
|
|
var strLogPath;
|
|
var sdFile;
|
|
var aPartsTo;
|
|
var strFileName;
|
|
|
|
strPostBuildMachineDir = PrivateData.objEnviron.BuildManager.Enlistment;
|
|
if (strPostBuildMachineDir.charAt(strPostBuildMachineDir.length - 1) == '\\')
|
|
strPostBuildMachineDir = substr(0, strPostBuildMachineDir.length - 1);
|
|
|
|
strLogPath = "\\\\" +
|
|
PrivateData.objEnviron.BuildManager.PostBuildMachine + "\\" +
|
|
strPostBuildMachineDir.charAt(0) + "$" +
|
|
strPostBuildMachineDir.slice(2) +
|
|
PUBLISHLOGFILE;
|
|
|
|
SPLogMsg("Creating publish.log file " + strLogPath);
|
|
PrivateData.objUtil.fnDeleteFileNoThrow(strLogPath);
|
|
sdFile = LogCreateTextFile(g_FSObj, strLogPath, true);
|
|
|
|
|
|
for(strFileName in PrivateData.hPublishedFiles)
|
|
{
|
|
if (!PrivateData.hPublishedFiles.__isPublicMember(strFileName))
|
|
continue;
|
|
|
|
objFile = PrivateData.hPublishedFiles[strFileName];
|
|
if (objFile.PublishedFile.strPublishedStatus == FS_ADDTOPUBLISHLOG)
|
|
{
|
|
// The first reference is always the reference into the
|
|
// non-duplicate "hPublisher" entry for this particular file.
|
|
// Any other aReferences entries will be duplicates.
|
|
objFile.PublishedFile.strPublishedStatus = FS_COMPLETE;
|
|
nDirLength = objFile.aReferences[0].strDir.length; // For example: "C:\mt\nt";
|
|
if (nDirLength > 0)
|
|
{ // If strDir happened to include a trailing "\", remove it.
|
|
if (objFile.aReferences[0].strDir.charAt(nDirLength - 1) == '\\')
|
|
nDirLength--;
|
|
}
|
|
JAssert(objFile.aReferences[0].strDir.IsEqualNoCase(objFile.PublishedFile.strName.substr(0, nDirLength)));
|
|
strPostBuildFileName = strPostBuildMachineDir + // Example: "F:\nt"
|
|
objFile.PublishedFile.strName.substr(nDirLength); // Example: \public\sdk\lib\i386\uuid.lib
|
|
var aPartsTo = strPostBuildFileName.SplitFileName();
|
|
strSrcName = "\\\\" +
|
|
objFile.aReferences[0].strName + "\\" +
|
|
objFile.aReferences[0].strDir.charAt(0) + "$" +
|
|
objFile.PublishedFile.strName.slice(2);
|
|
|
|
sdFile.WriteLine(strPostBuildFileName + " " + strSrcName + " " + aPartsTo[1] + aPartsTo[2]);
|
|
}
|
|
}
|
|
sdFile.Close();
|
|
}
|
|
|
|
/*
|
|
PublishFilesInEnlistment
|
|
Called once for each enlistment on the remote machine.
|
|
*/
|
|
function PublishFilesInEnlistment(objPublishedFiles)
|
|
{
|
|
JAssert(g_strRemoteMachineName == objPublishedFiles.strLocalMachine, "(" + g_strRemoteMachineName + ") " + "PublishFilesInEnlistment - local machine name doesn't match!");
|
|
|
|
var PubData;
|
|
var publishEnlistment;
|
|
var i;
|
|
var nFileCount = objPublishedFiles.aNames.length;
|
|
var strSrcUNCPrefix = MakeUNCPath(objPublishedFiles.strLocalMachine,
|
|
objPublishedFiles.strRootDir,
|
|
"");
|
|
|
|
SPLogMsg("Publish files from host " +
|
|
objPublishedFiles.strLocalMachine +
|
|
", enlistment is " +
|
|
objPublishedFiles.strRootDir);
|
|
|
|
if (PrivateData.hPublisher[objPublishedFiles.strLocalMachine] == null)
|
|
{
|
|
PrivateData.hPublisher[objPublishedFiles.strLocalMachine] = new Publisher();
|
|
}
|
|
PubData = PrivateData.hPublisher[objPublishedFiles.strLocalMachine];
|
|
if (PubData.hPublishEnlistment[objPublishedFiles.strRootDir] == null)
|
|
PubData.hPublishEnlistment[objPublishedFiles.strRootDir] = new PublishEnlistment;
|
|
|
|
publishEnlistment = PubData.hPublishEnlistment[objPublishedFiles.strRootDir];
|
|
publishEnlistment.strSrcUNCPrefix = strSrcUNCPrefix;
|
|
|
|
for(i = 0; i < nFileCount; ++i)
|
|
{
|
|
var file = new PublishedFile();
|
|
SPLogMsg("Published file[" + i + "] " + objPublishedFiles.aNames[i]);
|
|
file.strPublishedStatus = FS_NOTYETCOPIED;
|
|
file.strName = objPublishedFiles.aNames[i];
|
|
publishEnlistment.aPublishedFile[publishEnlistment.aPublishedFile.length] = file;
|
|
}
|
|
}
|
|
|
|
function CreateListOfPublishedFiles(strOldPublishedStatus, strNewPublishedStatus)
|
|
{
|
|
try
|
|
{
|
|
var i;
|
|
var PubData = PrivateData.hPublisher[g_strRemoteMachineName];
|
|
var strSDRoot;
|
|
var publishEnlistment;
|
|
var aPublishedEnlistments = new Array();
|
|
var objFiles;
|
|
|
|
for (strSDRoot in PubData.hPublishEnlistment)
|
|
{
|
|
if (!PubData.hPublishEnlistment.__isPublicMember(strSDRoot))
|
|
continue;
|
|
|
|
publishEnlistment = PubData.hPublishEnlistment[strSDRoot];
|
|
objFiles = new Object();
|
|
objFiles.strLocalMachine = g_strRemoteMachineName;
|
|
objFiles.strRootDir = strSDRoot;
|
|
objFiles.aNames = new Array();
|
|
|
|
for (i = 0; i < publishEnlistment.aPublishedFile.length; ++i)
|
|
{
|
|
if (publishEnlistment.aPublishedFile[i].strPublishedStatus == strOldPublishedStatus)
|
|
{
|
|
SPLogMsg("Published file: " + publishEnlistment.aPublishedFile[i].strName);
|
|
objFiles.aNames[objFiles.aNames.length] = publishEnlistment.aPublishedFile[i].strName;
|
|
publishEnlistment.aPublishedFile[i].strPublishedStatus = strNewPublishedStatus;
|
|
}
|
|
}
|
|
aPublishedEnlistments[aPublishedEnlistments.length] = objFiles;
|
|
}
|
|
}
|
|
catch(ex)
|
|
{
|
|
SPLogMsg("an error occurred while executing 'CreateListOfPublishedFiles'\n" + ex);
|
|
throw ex;
|
|
}
|
|
return aPublishedEnlistments;
|
|
}
|
|
|
|
/*
|
|
Copy all Publushed files to the remote machines
|
|
*/
|
|
function CopyFilesToSlaves()
|
|
{
|
|
var strFileName;
|
|
var aStrSrcUNCPrefix = new Array(); // Array of enlistment UNCs for this machine
|
|
var hEnlistments = new Object();
|
|
var strSDRoot;
|
|
var i = 0;
|
|
var j;
|
|
var aReferences;
|
|
var aNames = new Array();
|
|
var nEnlistments = 0;
|
|
try
|
|
{
|
|
// First, make a list of my enlistments
|
|
for(i = 0; i < PrivateData.objEnviron.Machine.length; ++i)
|
|
{
|
|
if (PrivateData.objEnviron.Machine[i].Name.IsEqualNoCase(g_strRemoteMachineName))
|
|
{
|
|
// SPLogMsg("hEnlistments[" + PrivateData.objEnviron.Machine[i].Enlistment + "] = 1");
|
|
hEnlistments[PrivateData.objEnviron.Machine[i].Enlistment] = 1;
|
|
nEnlistments++;
|
|
aStrSrcUNCPrefix[aStrSrcUNCPrefix.length] = MakeUNCPath(g_strRemoteMachineName, PrivateData.objEnviron.Machine[i].Enlistment, "");
|
|
}
|
|
}
|
|
|
|
// Now for each file, add it to the list of files to copy.
|
|
for(strFileName in PrivateData.hPublishedFiles)
|
|
{
|
|
if (!PrivateData.hPublishedFiles.__isPublicMember(strFileName))
|
|
continue;
|
|
|
|
ScanEnlistments:
|
|
for(i = 0; i < aStrSrcUNCPrefix.length; ++i)
|
|
{
|
|
// Optimization: If a slave has only one enlistment, and
|
|
// the slave generated this file, do not copy it
|
|
SPLogMsg("File " + strFileName + " status is " + PrivateData.hPublishedFiles[strFileName].PublishedFile.strPublishedStatus);
|
|
if (PrivateData.hPublishedFiles[strFileName].PublishedFile.strPublishedStatus == FS_COPYTOSLAVE)
|
|
{
|
|
// SPLogMsg("nEnlistments = " + nEnlistments);
|
|
if (nEnlistments == 1)
|
|
{
|
|
aReferences = PrivateData.hPublishedFiles[strFileName].aReferences;
|
|
for(j = 0; j < aReferences.length; ++j)
|
|
{
|
|
// SPLogMsg("aReferences[" + j + "].strName = " + aReferences[j].strName + ", " + aReferences[j].strDir);
|
|
if (g_strRemoteMachineName == aReferences[j].strName)
|
|
{
|
|
if (hEnlistments[aReferences[j].strDir] != null)
|
|
{
|
|
SPLogMsg("Optimizing out copy of " + strFileName + " to " + aStrSrcUNCPrefix[i] + strFileName);
|
|
continue ScanEnlistments;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// BUGBUG: This is supposed to specify which enlistment on the slave machine to copy to.
|
|
// It does not. Thus the for "i" loop is irrelavent.
|
|
// If we ever support multiple enlistments on a machine, this will be a problem.
|
|
aNames[aNames.length] = strFileName;
|
|
}
|
|
}
|
|
}
|
|
return PrivateData.hRemoteMachine[g_strRemoteMachineName].objRemote.Exec('copyfilesfrompostbuildtoslave', PrivateData.objUtil.fnUneval(aNames));
|
|
}
|
|
catch(ex)
|
|
{
|
|
SPLogMsg("an error occurred while executing 'CopyFilesToSlaves'\n" + ex);
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
// This oughta be a member of PublishedFiles.
|
|
function PublishedFilesAddReference(obj, strMachineName, strSDRoot)
|
|
{
|
|
var nCount = obj.aReferences.length;
|
|
obj.aReferences[nCount] = new DepotInfo;
|
|
obj.aReferences[nCount].strName = strMachineName;
|
|
obj.aReferences[nCount].strDir = strSDRoot;
|
|
}
|
|
|
|
/*
|
|
This function gets called to merge each machines published files into the
|
|
global list of files.
|
|
|
|
When a file is published its status defaults to FS_NOTYETCOPIED. If a
|
|
FS_NOTYETCOPIED file is encountered, and it is found in the global
|
|
list of files (PrivateData.hPublishedFiles), then it is marked FS_DUPLICATE, and reported.
|
|
Otherwise it is added to PrivateData.hPublishedFiles.
|
|
|
|
*/
|
|
function RemoveDuplicateFileNames()
|
|
{
|
|
TakeThreadLock('RemoveDuplicates');
|
|
try
|
|
{
|
|
var i;
|
|
var PubData = PrivateData.hPublisher[g_strRemoteMachineName];
|
|
var strSDRoot;
|
|
var publishEnlistment;
|
|
var strFileName;
|
|
var objPublishedFiles;
|
|
var n;
|
|
var strSDRootPublic;
|
|
|
|
for (strSDRoot in PubData.hPublishEnlistment)
|
|
{
|
|
if (!PubData.hPublishEnlistment.__isPublicMember(strSDRoot))
|
|
continue;
|
|
|
|
strSDRootPublic = strSDRoot + "\\Public";
|
|
publishEnlistment = PubData.hPublishEnlistment[strSDRoot];
|
|
for (i = 0; i < publishEnlistment.aPublishedFile.length; ++i)
|
|
{
|
|
strFileName = publishEnlistment.aPublishedFile[i].strName.slice(strSDRootPublic.length).toLowerCase();
|
|
if (publishEnlistment.aPublishedFile[i].strPublishedStatus == FS_NOTYETCOPIED)
|
|
{
|
|
if (PrivateData.hPublishedFiles[strFileName] != null)
|
|
{
|
|
SPLogMsg("duplicate file eliminated: " + strFileName);
|
|
publishEnlistment.aPublishedFile[i].strPublishedStatus = FS_DUPLICATE;
|
|
}
|
|
else
|
|
{
|
|
objPublishedFiles = new PublishedFiles;
|
|
PrivateData.hPublishedFiles[strFileName] = objPublishedFiles;
|
|
PrivateData.hPublishedFiles[strFileName].PublishedFile = publishEnlistment.aPublishedFile[i];
|
|
}
|
|
// TODO: Place the enlistment name instead of strSDRoot.
|
|
PublishedFilesAddReference(PrivateData.hPublishedFiles[strFileName], g_strRemoteMachineName, strSDRoot);
|
|
}
|
|
else
|
|
{ // The file has already ben processed. Assert that we have an entry in hPublishedFiles.
|
|
JAssert(PrivateData.hPublishedFiles[strFileName] != null, "(" + g_strRemoteMachineName + ") ");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch(ex)
|
|
{
|
|
ReleaseThreadLock('RemoveDuplicates');
|
|
SPLogMsg("an error occurred while executing 'RemoveDuplicateFileNames " + ex);
|
|
throw ex;
|
|
}
|
|
ReleaseThreadLock('RemoveDuplicates');
|
|
}
|
|
|
|
|
|
function RemoteWrapper(strMachineName)
|
|
{
|
|
RemoteWrapper.prototype.Exec = RemoteWrapperExec;
|
|
RemoteWrapper.prototype.StatusValue = RemoteWrapperStatusValue;
|
|
RemoteWrapper.prototype.Connect = RemoteWrapperConnect;
|
|
RemoteWrapper.prototype.Register = RemoteWrapperRegister;
|
|
RemoteWrapper.prototype.Unregister = RemoteWrapperUnregister;
|
|
RemoteWrapper.prototype.Reconnect = RemoteWrapperReconnect;
|
|
RemoteWrapper.prototype.VersionCheck = RemoteWrapperVersionCheck;
|
|
RemoteWrapper.prototype.RetryCmd = RemoteWrapperRetryCmd;
|
|
RemoteWrapper.strErrorMessage = "";
|
|
|
|
this.fRegistered = false;
|
|
this.strMachineName = strMachineName;
|
|
this.fMachineReset = false;
|
|
this.Connect(strMachineName, true);
|
|
this.ex = null;
|
|
}
|
|
|
|
function RemoteWrapperConnect(strMachineName, fThrow)
|
|
{
|
|
try
|
|
{
|
|
SPLogMsg("Attempting to connect to " + strMachineName);
|
|
this.obj = new ActiveXObject('MTScript.Remote', strMachineName);
|
|
this.strErrorMessage = "";
|
|
this.VersionCheck();
|
|
return true;
|
|
}
|
|
catch(ex)
|
|
{
|
|
SPLogMsg("CONNECTION TO " + strMachineName + " FAILED " + ex);
|
|
this.strErrorMessage = "" + ex;
|
|
if (fThrow)
|
|
throw ex;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function RemoteWrapperReconnect()
|
|
{
|
|
var Attempts = 1; // COM tries long and hard to make the connection. No need to prolong things.
|
|
var ex;
|
|
|
|
SPLogMsg("Attempting to reconnect");
|
|
while(Attempts > 0)
|
|
{
|
|
try
|
|
{
|
|
this.Connect(this.strMachineName, true);
|
|
if (this.fRegistered)
|
|
this.Register();
|
|
|
|
this.strErrorMessage = "";
|
|
SPLogMsg("RECONNECTED!");
|
|
return true;
|
|
}
|
|
catch(ex)
|
|
{
|
|
}
|
|
|
|
--Attempts;
|
|
if (Attempts)
|
|
{
|
|
SPLogMsg("Wait 1 sec then retry");
|
|
Sleep(1000);
|
|
}
|
|
}
|
|
SPLogMsg("Reconnect failed");
|
|
this.obj = null;
|
|
ResetSync(g_SlaveProxyWaitFor[2]);
|
|
return false;
|
|
}
|
|
|
|
function RemoteWrapperVersionCheck()
|
|
{
|
|
var nMajor = this.obj.HostMajorVer;
|
|
var nMinor = this.obj.HostMinorVer;
|
|
if (nMajor != HostMajorVer || nMinor != HostMinorVer)
|
|
{
|
|
throw Error(-1, "Host version does not match remote host. (" + HostMajorVer + "." + HostMinorVer + ") != (" + nMajor + "." + nMinor + ")");
|
|
}
|
|
}
|
|
|
|
function RemoteWrapperExec(msg,params)
|
|
{
|
|
return this.RetryCmd('exec', 'this.obj.Exec(' + UnevalString(msg) + ',' + UnevalString(params) + ')');
|
|
}
|
|
|
|
function RemoteWrapperStatusValue(nIndex)
|
|
{
|
|
return this.RetryCmd('StatusValue', 'this.obj.StatusValue(' + nIndex + ')');
|
|
}
|
|
|
|
function RemoteWrapperRetryCmd(strOp, strCmd)
|
|
{
|
|
var ex = this.ex;
|
|
var vRet;
|
|
var Attempts = 2;
|
|
var ConnectAttempts;
|
|
var objOld;
|
|
var strTmp;
|
|
try
|
|
{
|
|
do
|
|
{
|
|
if (!this.obj)
|
|
{
|
|
if (this.fMachineReset || !this.Reconnect())
|
|
break;
|
|
|
|
strTmp = MyEval(this.obj.Exec('getpublic', 'PublicData.strMode'));
|
|
if (strTmp == 'idle')
|
|
{
|
|
this.strErrorMessage = "Remote machine has reset -- ";
|
|
if (g_fOKToRestartLostMachine)
|
|
this.strErrorMessage += "attempting to reconnect";
|
|
else
|
|
this.strErrorMessage += "build failed";
|
|
|
|
this.fMachineReset = true;
|
|
ex = new Error(-1, this.strErrorMessage);
|
|
delete this.obj;
|
|
break;
|
|
}
|
|
}
|
|
if (this.obj)
|
|
{
|
|
try
|
|
{
|
|
vRet = eval(strCmd);
|
|
return vRet;
|
|
}
|
|
catch(ex)
|
|
{
|
|
this.strErrorMessage = "" + ex;
|
|
SPLogMsg(strOp + " " + strCmd + " FAILED, " + ex);
|
|
this.obj = null;
|
|
}
|
|
}
|
|
--Attempts;
|
|
}
|
|
while(Attempts > 0);
|
|
SetDisconnectedDepotStatus(this.strErrorMessage);
|
|
SPLogMsg("Unable to reestablish connection");
|
|
}
|
|
catch(ex2)
|
|
{
|
|
SPLogMsg("Unexpected exception " + ex2);
|
|
}
|
|
this.ex = ex;
|
|
throw ex;
|
|
}
|
|
|
|
function RemoteWrapperRegister()
|
|
{
|
|
SPLogMsg("Attempting to register");
|
|
RegisterEventSource(this.obj);
|
|
this.fRegistered = true;
|
|
SPLogMsg("Registered");
|
|
}
|
|
|
|
function RemoteWrapperUnregister()
|
|
{
|
|
if (this.fRegistered)
|
|
UnregisterEventSource(this.obj);
|
|
|
|
this.fRegistered = false;
|
|
}
|
|
|
|
function getspdata()
|
|
{
|
|
var pd1;
|
|
var pd2;
|
|
var o1;
|
|
var o2;
|
|
var nTracePoint = 0;
|
|
try
|
|
{
|
|
nTracePoint = 1;
|
|
nTracePoint = 2;
|
|
SPLogMsg("getspdata " + g_strRemoteMachineName);
|
|
nTracePoint = 3;
|
|
pd1 = PrivateData.objUtil.fnUneval(PublicData);
|
|
nTracePoint = 4;
|
|
pd1 = PrivateData.objUtil.fnUneval(PrivateData);
|
|
nTracePoint = 5;
|
|
|
|
debugger;
|
|
LogMsg(pd1);
|
|
LogMsg(pd2);
|
|
nTracePoint = 6;
|
|
|
|
o1 = MyEval(pd1);
|
|
nTracePoint = 7;
|
|
o2 = MyEval(pd2);
|
|
nTracePoint = 8;
|
|
}
|
|
catch(ex)
|
|
{
|
|
SPLogMsg("Exception at point " + nTracePoint + " thrown processing 'getspdata'" + ex);
|
|
debugger;
|
|
}
|
|
}
|