def __init__(self,
aoEntries,
iPage,
cItemsPerPage,
tsEffective,
fnDPrint,
oDisp,
cDaysBack,
aiSelectedSortColumns=None):
WuiListContentBase.__init__(
self,
aoEntries,
iPage,
cItemsPerPage,
tsEffective,
'System Changelog',
fnDPrint=fnDPrint,
oDisp=oDisp,
aiSelectedSortColumns=aiSelectedSortColumns)
self._asColumnHeaders = ['When', 'User', 'Event', 'Details']
self._asColumnAttribs = ['align="center"', 'align="center"', '', '']
self._oBuildBlacklistLogic = BuildBlacklistLogic(oDisp.getDb())
self._oBuildLogic = BuildLogic(oDisp.getDb())
self._oBuildSourceLogic = BuildSourceLogic(oDisp.getDb())
self._oFailureCategoryLogic = FailureCategoryLogic(oDisp.getDb())
self._oFailureReasonLogic = FailureReasonLogic(oDisp.getDb())
self._oGlobalResourceLogic = GlobalResourceLogic(oDisp.getDb())
self._oSchedGroupLogic = SchedGroupLogic(oDisp.getDb())
self._oTestBoxLogic = TestBoxLogic(oDisp.getDb())
self._oTestCaseLogic = TestCaseLogic(oDisp.getDb())
self._oTestGroupLogic = TestGroupLogic(oDisp.getDb())
self._oUserAccountLogic = UserAccountLogic(oDisp.getDb())
self._sPrevDate = ''
_ = cDaysBack
def __init__(self, oData, sMode, oDisp):
assert isinstance(oData, SchedGroupData)
if sMode == WuiFormContentBase.ksMode_Add:
sTitle = 'New Scheduling Group'
elif sMode == WuiFormContentBase.ksMode_Edit:
sTitle = 'Edit Scheduling Group'
else:
assert sMode == WuiFormContentBase.ksMode_Show
sTitle = 'Scheduling Group'
WuiFormContentBase.__init__(self, oData, sMode, 'SchedGroup', oDisp,
sTitle)
# Read additional bits form the DB, unless we're in
if sMode != WuiFormContentBase.ksMode_Show:
self._aoAllRelevantTestGroups = TestGroupLogic(
oDisp.getDb()).getAll()
self._aoAllRelevantTestBoxes = TestBoxLogic(
oDisp.getDb()).getAll()
else:
self._aoAllRelevantTestGroups = [
oMember.oTestGroup for oMember in oData.aoMembers
]
self._aoAllRelevantTestBoxes = [
oMember.oTestBox for oMember in oData.aoTestBoxes
]
def removeEntry(self, uidAuthor, idSchedGroup, fCascade = False, fCommit = False):
"""
Deletes a scheduling group.
"""
#
# Input validation and retrival of current data.
#
if idSchedGroup == 1:
raise TMRowInUse('Cannot remove the default scheduling group (id 1).');
oData = SchedGroupDataEx().initFromDbWithId(self._oDb, idSchedGroup);
#
# We use cascade a little different here... We don't actually delete
# associated testboxes or testgroups.
#
if oData.aoTestBoxes:
if fCascade is not True:
# Complain about there being associated testboxes.
asTestBoxes = ['%s (#%d)' % (oTestBox.sName, oTestBox.idTestBox) for oTestBox in oData.aoTestBoxes];
raise TMRowInUse('Scheduling group #%d is associated with one or more test boxes: %s'
% (idSchedGroup, ', '.join(asTestBoxes),));
else:
# Reassign testboxes to scheduling group #1 (the default group).
oTbLogic = TestBoxLogic(self._oDb);
for oTestBox in oData.aoTestBoxes:
oTbCopy = TestBoxData().initFromOther(oTestBox);
oTbCopy.idSchedGroup = 1;
oTbLogic.editEntry(oTbCopy, uidAuthor, fCommit = False);
oData = SchedGroupDataEx().initFromDbWithId(self._oDb, idSchedGroup);
if oData.aoTestBoxes:
raise TMRowInUse('More testboxes was added to the scheduling group as we were trying to delete it.');
#
# Remove the group and all member records.
#
for oMember in oData.aoMembers:
self._removeSchedGroupMember(uidAuthor, oMember);
self._oDb.execute('UPDATE SchedGroupMembers\n'
'SET tsExpire = CURRENT_TIMESTAMP\n'
'WHERE idSchedGroup = %s\n'
' AND tsExpire = \'infinity\'::TIMESTAMP\n'
, (idSchedGroup,));
(tsCur, tsCurMinusOne) = self._oDb.getCurrentTimestamps();
if oData.tsEffective != tsCur and oData.tsEffective != tsCurMinusOne:
self._historizeEntry(idSchedGroup, tsCurMinusOne);
self._readdEntry(uidAuthor, oData, tsCurMinusOne);
self._historizeEntry(idSchedGroup);
self._oDb.execute('UPDATE SchedGroups\n'
'SET tsExpire = CURRENT_TIMESTAMP\n'
'WHERE idSchedGroup = %s\n'
' AND tsExpire = \'infinity\'::TIMESTAMP\n'
, (idSchedGroup,))
self._oDb.maybeCommit(fCommit)
return True;
def _actionTestBoxListPost(self):
"""Actions on a list of testboxes."""
# Parameters.
aidTestBoxes = self.getListOfIntParams(TestBoxData.ksParam_idTestBox, iMin = 1, aiDefaults = []);
sListAction = self.getStringParam(self.ksParamListAction);
if sListAction in [asDesc[0] for asDesc in WuiTestBoxList.kasTestBoxActionDescs]:
idAction = None;
else:
asActionPrefixes = [ 'setgroup-', ];
i = 0;
while i < len(asActionPrefixes) and not sListAction.startswith(asActionPrefixes[i]):
i += 1;
if i >= len(asActionPrefixes):
raise WuiException('Parameter "%s" has an invalid value: "%s"' % (self.ksParamListAction, sListAction,));
idAction = sListAction[len(asActionPrefixes[i]):];
if not idAction.isdigit():
raise WuiException('Parameter "%s" has an invalid value: "%s"' % (self.ksParamListAction, sListAction,));
idAction = int(idAction);
sListAction = sListAction[:len(asActionPrefixes[i]) - 1];
self._checkForUnknownParameters();
# Take action.
if sListAction is 'none':
pass;
else:
oLogic = TestBoxLogic(self._oDb);
aoTestBoxes = []
for idTestBox in aidTestBoxes:
aoTestBoxes.append(TestBoxData().initFromDbWithId(self._oDb, idTestBox));
if sListAction in [ 'enable', 'disable' ]:
fEnable = sListAction == 'enable';
for oTestBox in aoTestBoxes:
if oTestBox.fEnabled != fEnable:
oTestBox.fEnabled = fEnable;
oLogic.editEntry(oTestBox, self._oCurUser.uid, fCommit = False);
elif sListAction == 'setgroup':
for oTestBox in aoTestBoxes:
if oTestBox.idSchedGroup != idAction:
oTestBox.idSchedGroup = idAction;
oLogic.editEntry(oTestBox, self._oCurUser.uid, fCommit = False);
else:
for oTestBox in aoTestBoxes:
if oTestBox.enmPendingCmd != sListAction:
oTestBox.enmPendingCmd = sListAction;
oLogic.editEntry(oTestBox, self._oCurUser.uid, fCommit = False);
self._oDb.commit();
# Re-display the list.
self._sPageTitle = None;
self._sPageBody = None;
self._sRedirectTo = self._sActionUrlBase + self.ksActionTestBoxList;
return True;
def _doCommandAckNck(self, sCmd):
""" Implements ACK, NACK and NACK(ENOTSUP). """
(oDb, _, _) = self._connectToDbAndValidateTb()
if oDb is None:
return False
#
# If the command maps to a TestBoxCmd_T value, it means we have to
# check and update TestBoxes. If it's an ACK, the testbox status will
# need updating as well.
#
sPendingCmd = TestBoxController.kdTbRespCmdToCmd[sCmd]
if sPendingCmd is not None:
oTestBoxLogic = TestBoxLogic(oDb)
oTestBoxLogic.setCommand(self._idTestBox,
sOldCommand=sPendingCmd,
sNewCommand=TestBoxData.ksTestBoxCmd_None,
fCommit=False)
if self._sAction == constants.tbreq.COMMAND_ACK \
and TestBoxController.kdCmdToState[sPendingCmd] is not None:
oStatusLogic = TestBoxStatusLogic(oDb)
oStatusLogic.updateState(
self._idTestBox,
TestBoxController.kdCmdToState[sPendingCmd],
fCommit=False)
# Commit the two updates.
oDb.commit()
#
# Log NACKs.
#
if self._sAction != constants.tbreq.COMMAND_ACK:
oSysLogLogic = SystemLogLogic(oDb)
oSysLogLogic.addEntry(SystemLogData.ksEvent_CmdNacked,
'idTestBox=%s sCmd=%s' %
(self._idTestBox, sPendingCmd),
24,
fCommit=True)
return self._resultResponse(constants.tbresp.STATUS_ACK)
def _doRequestCommand(self, fIdle):
"""
Common code for handling command request.
"""
(oDb, oStatusData, oTestBoxData) = self._connectToDbAndValidateTb()
if oDb is None:
return False
#
# Status clean up.
#
# Only when BUSY will the TestBox Script request and execute commands
# concurrently. So, it must be idle when sending REQUEST_COMMAND_IDLE.
#
if fIdle:
if oStatusData.enmState == TestBoxStatusData.ksTestBoxState_GangGathering:
self._doGangGathering(oDb, oStatusData)
elif oStatusData.enmState == TestBoxStatusData.ksTestBoxState_GangGatheringTimedOut:
self._doGangGatheringTimedOut(oDb, oStatusData)
elif oStatusData.enmState == TestBoxStatusData.ksTestBoxState_GangTesting:
dResponse = SchedulerBase.composeExecResponse(
oDb, oTestBoxData.idTestBox, self._oSrvGlue.getBaseUrl())
if dResponse is not None:
return dResponse
elif oStatusData.enmState == TestBoxStatusData.ksTestBoxState_GangCleanup:
self._doGangCleanup(oDb, oStatusData)
elif oStatusData.enmState != TestBoxStatusData.ksTestBoxState_Idle: # (includes ksTestBoxState_GangGatheringTimedOut)
self._cleanupOldTest(oDb, oStatusData)
#
# Check for pending command.
#
if oTestBoxData.enmPendingCmd != TestBoxData.ksTestBoxCmd_None:
asValidCmds = TestBoxController.kasIdleCmds if fIdle else TestBoxController.kasBusyCmds
if oTestBoxData.enmPendingCmd in asValidCmds:
dResponse = {
constants.tbresp.ALL_PARAM_RESULT:
TestBoxController.kdCmdToTbRespCmd[
oTestBoxData.enmPendingCmd]
}
if oTestBoxData.enmPendingCmd in [
TestBoxData.ksTestBoxCmd_Upgrade,
TestBoxData.ksTestBoxCmd_UpgradeAndReboot
]:
dResponse[constants.tbresp.
UPGRADE_PARAM_URL] = self._oSrvGlue.getBaseUrl(
) + TestBoxController.ksUpgradeZip
return self._writeResponse(dResponse)
if oTestBoxData.enmPendingCmd == TestBoxData.ksTestBoxCmd_Abort and fIdle:
TestBoxLogic(oDb).setCommand(
self._idTestBox,
sOldCommand=oTestBoxData.enmPendingCmd,
sNewCommand=TestBoxData.ksTestBoxCmd_None,
fCommit=True)
#
# If doing gang stuff, return 'CMD_WAIT'.
#
## @todo r=bird: Why is GangTesting included here? Figure out when testing gang testing.
if oStatusData.enmState in [
TestBoxStatusData.ksTestBoxState_GangGathering,
TestBoxStatusData.ksTestBoxState_GangTesting,
TestBoxStatusData.ksTestBoxState_GangCleanup
]:
return self._resultResponse(constants.tbresp.CMD_WAIT)
#
# If idling and enabled try schedule a new task.
#
if fIdle \
and oTestBoxData.fEnabled \
and not TestSetLogic(oDb).isTestBoxExecutingToRapidly(oTestBoxData.idTestBox) \
and oStatusData.enmState == TestBoxStatusData.ksTestBoxState_Idle: # (paranoia)
dResponse = SchedulerBase.scheduleNewTask(
oDb, oTestBoxData, oStatusData.iWorkItem,
self._oSrvGlue.getBaseUrl())
if dResponse is not None:
return self._writeResponse(dResponse)
#
# Touch the status row every couple of mins so we can tell that the box is alive.
#
oStatusLogic = TestBoxStatusLogic(oDb)
if oStatusData.enmState != TestBoxStatusData.ksTestBoxState_GangGathering \
and oStatusLogic.timeSinceLastChangeInSecs(oStatusData) >= TestBoxStatusLogic.kcSecIdleTouchStatus:
oStatusLogic.touchStatus(oTestBoxData.idTestBox, fCommit=True)
return self._idleResponse()
def _actionSignOn(self): # pylint: disable=R0914
""" Implement sign-on """
#
# Validate parameters (raises exception on failure).
#
sOs = self._getStringParam(constants.tbreq.SIGNON_PARAM_OS,
coreconsts.g_kasOses)
sOsVersion = self._getStringParam(
constants.tbreq.SIGNON_PARAM_OS_VERSION)
sCpuVendor = self._getStringParam(
constants.tbreq.SIGNON_PARAM_CPU_VENDOR)
sCpuArch = self._getStringParam(constants.tbreq.SIGNON_PARAM_CPU_ARCH,
coreconsts.g_kasCpuArches)
sCpuName = self._getStringParam(constants.tbreq.SIGNON_PARAM_CPU_NAME,
fStrip=True,
sDefValue='')
# new
lCpuRevision = self._getLongParam(
constants.tbreq.SIGNON_PARAM_CPU_REVISION, lMin=0, lDefValue=0)
# new
cCpus = self._getIntParam(constants.tbreq.SIGNON_PARAM_CPU_COUNT, 1,
16384)
fCpuHwVirt = self._getBoolParam(
constants.tbreq.SIGNON_PARAM_HAS_HW_VIRT)
fCpuNestedPaging = self._getBoolParam(
constants.tbreq.SIGNON_PARAM_HAS_NESTED_PAGING)
fCpu64BitGuest = self._getBoolParam(
constants.tbreq.SIGNON_PARAM_HAS_64_BIT_GUEST, fDefValue=True)
fChipsetIoMmu = self._getBoolParam(
constants.tbreq.SIGNON_PARAM_HAS_IOMMU)
fRawMode = self._getBoolParam(
constants.tbreq.SIGNON_PARAM_WITH_RAW_MODE, fDefValue=None)
cMbMemory = self._getLongParam(constants.tbreq.SIGNON_PARAM_MEM_SIZE,
8, 1073741823)
# 8MB..1PB
cMbScratch = self._getLongParam(
constants.tbreq.SIGNON_PARAM_SCRATCH_SIZE, 0, 1073741823)
# 0..1PB
sReport = self._getStringParam(constants.tbreq.SIGNON_PARAM_REPORT,
fStrip=True,
sDefValue='')
# new
iTestBoxScriptRev = self._getIntParam(
constants.tbreq.SIGNON_PARAM_SCRIPT_REV, 1, 100000000)
iPythonHexVersion = self._getIntParam(
constants.tbreq.SIGNON_PARAM_PYTHON_VERSION, 0x020300f0,
0x030f00f0)
self._checkForUnknownParameters()
# Null conversions for new parameters.
if not sReport:
sReport = None
if not sCpuName:
sCpuName = None
if lCpuRevision <= 0:
lCpuRevision = None
#
# Connect to the database and validate the testbox.
#
oDb = TMDatabaseConnection(self._oSrvGlue.dprint)
oTestBoxLogic = TestBoxLogic(oDb)
oTestBox = oTestBoxLogic.tryFetchTestBoxByUuid(self._sTestBoxUuid)
if oTestBox is None:
oSystemLogLogic = SystemLogLogic(oDb)
oSystemLogLogic.addEntry(SystemLogData.ksEvent_TestBoxUnknown,
'addr=%s uuid=%s os=%s %d cpus' \
% (self._sTestBoxAddr, self._sTestBoxUuid, sOs, cCpus),
24, fCommit = True)
return self._resultResponse(constants.tbresp.STATUS_NACK)
#
# Update the row in TestBoxes if something changed.
#
if oTestBox.cMbScratch is not None and oTestBox.cMbScratch != 0:
cPctScratchDiff = (cMbScratch -
oTestBox.cMbScratch) * 100 / oTestBox.cMbScratch
else:
cPctScratchDiff = 100
# pylint: disable=R0916
if self._sTestBoxAddr != oTestBox.ip \
or sOs != oTestBox.sOs \
or sOsVersion != oTestBox.sOsVersion \
or sCpuVendor != oTestBox.sCpuVendor \
or sCpuArch != oTestBox.sCpuArch \
or sCpuName != oTestBox.sCpuName \
or lCpuRevision != oTestBox.lCpuRevision \
or cCpus != oTestBox.cCpus \
or fCpuHwVirt != oTestBox.fCpuHwVirt \
or fCpuNestedPaging != oTestBox.fCpuNestedPaging \
or fCpu64BitGuest != oTestBox.fCpu64BitGuest \
or fChipsetIoMmu != oTestBox.fChipsetIoMmu \
or fRawMode != oTestBox.fRawMode \
or cMbMemory != oTestBox.cMbMemory \
or abs(cPctScratchDiff) >= min(4 + cMbScratch / 10240, 12) \
or sReport != oTestBox.sReport \
or iTestBoxScriptRev != oTestBox.iTestBoxScriptRev \
or iPythonHexVersion != oTestBox.iPythonHexVersion:
oTestBoxLogic.updateOnSignOn(oTestBox.idTestBox,
oTestBox.idGenTestBox,
sTestBoxAddr=self._sTestBoxAddr,
sOs=sOs,
sOsVersion=sOsVersion,
sCpuVendor=sCpuVendor,
sCpuArch=sCpuArch,
sCpuName=sCpuName,
lCpuRevision=lCpuRevision,
cCpus=cCpus,
fCpuHwVirt=fCpuHwVirt,
fCpuNestedPaging=fCpuNestedPaging,
fCpu64BitGuest=fCpu64BitGuest,
fChipsetIoMmu=fChipsetIoMmu,
fRawMode=fRawMode,
cMbMemory=cMbMemory,
cMbScratch=cMbScratch,
sReport=sReport,
iTestBoxScriptRev=iTestBoxScriptRev,
iPythonHexVersion=iPythonHexVersion)
#
# Update the testbox status, making sure there is a status.
#
oStatusLogic = TestBoxStatusLogic(oDb)
oStatusData = oStatusLogic.tryFetchStatus(oTestBox.idTestBox)
if oStatusData is not None:
self._cleanupOldTest(oDb, oStatusData)
else:
oStatusLogic.insertIdleStatus(oTestBox.idTestBox,
oTestBox.idGenTestBox,
fCommit=True)
#
# ACK the request.
#
dResponse = \
{
constants.tbresp.ALL_PARAM_RESULT: constants.tbresp.STATUS_ACK,
constants.tbresp.SIGNON_PARAM_ID: oTestBox.idTestBox,
constants.tbresp.SIGNON_PARAM_NAME: oTestBox.sName,
}
return self._writeResponse(dResponse)
