""" Action for running a test locally or on a remote machine """ import plugins, os, logging, subprocess, sys, signal, pipes from time import sleep from threading import Lock, Timer from jobprocess import killSubProcessAndChildren plugins.addCategory("killed", "killed", "were terminated before completion") class Running(plugins.TestState): def __init__(self, execMachines, freeText = "", briefText = "", lifecycleChange="start"): plugins.TestState.__init__(self, "running", freeText, briefText, started=1, executionHosts = execMachines, lifecycleChange=lifecycleChange) def makeModifiedState(self, newRunStatus, newDetails, lifecycleChange): currRunStatus = self.briefText.split()[0] if newRunStatus != currRunStatus: currFreeTextStatus = self.freeText.splitlines()[0].rsplit(" ", 2)[0] newFreeText = self.freeText.replace(currFreeTextStatus, newDetails) newBriefText = self.briefText.replace(currRunStatus, newRunStatus) return self.__class__(self.executionHosts, newFreeText, newBriefText, lifecycleChange) class Killed(plugins.TestState): def __init__(self, briefText, freeText, prevState): plugins.TestState.__init__(self, "killed", briefText=briefText, freeText=freeText, \ started=1, completed=1, executionHosts=prevState.executionHosts) # Cache running information, it can be useful to have this available... self.prevState = prevState self.failedPrediction = self
import os, performance, knownbugs, filecmp, string, plugins, shutil, logging from ordereddict import OrderedDict from tempfile import mktemp from comparefile import FileComparison plugins.addCategory("success", "succeeded") plugins.addCategory("failure", "FAILED") class BaseTestComparison(plugins.TestState): def __init__(self, category, previousInfo, completed, lifecycleChange=""): plugins.TestState.__init__(self, category, "", started=1, completed=completed, \ lifecycleChange=lifecycleChange, executionHosts=previousInfo.executionHosts) self.allResults = [] self.changedResults = [] self.newResults = [] self.missingResults = [] self.correctResults = [] self.diag = logging.getLogger("TestComparison") def hasResults(self): return len(self.allResults) > 0 def isAllNew(self): return len(self.newResults) == len(self.allResults) def findComparison(self, stem, includeSuccess=False): lists = [ self.changedResults, self.newResults, self.missingResults ] if includeSuccess: lists.append(self.correctResults) self.diag.info("Finding comparison for stem " + stem) for list in lists:
#!/usr/bin/env python import plugins, os, string, shutil, sys, logging, glob from ConfigParser import ConfigParser, NoOptionError from copy import copy from ordereddict import OrderedDict plugins.addCategory("bug", "known bugs", "had known bugs") plugins.addCategory("badPredict", "internal errors", "had internal errors") plugins.addCategory("crash", "CRASHED") # For backwards compatibility... class FailedPrediction(plugins.TestState): def getExitCode(self): return int(self.category != "bug") def getTypeBreakdown(self): status = "failure" if self.getExitCode() else "success" return status, self.briefText class Bug: def __init__(self, priority, rerunCount): self.priority = priority self.rerunCount = rerunCount def findCategory(self, internalError): if internalError or self.rerunCount: return "badPredict" else: return "bug"
""" import plugins, os, sys, socket, subprocess, signal, logging, time from utils import * from Queue import Queue from SocketServer import ThreadingTCPServer, StreamRequestHandler from threading import RLock from ordereddict import OrderedDict from default.console import TextDisplayResponder, InteractiveResponder from default.knownbugs import CheckForBugs from default.actionrunner import BaseActionRunner from default.performance import getTestPerformance from types import StringType from glob import glob plugins.addCategory("abandoned", "abandoned", "were abandoned") class Abandoned(plugins.TestState): def __init__(self, freeText): plugins.TestState.__init__(self, "abandoned", briefText="job deletion failed", \ freeText=freeText, completed=1, lifecycleChange="complete") class QueueSystemServer(BaseActionRunner): instance = None def __init__(self, optionMap, allApps): BaseActionRunner.__init__(self, optionMap, logging.getLogger("Queue System Submit")) # queue for putting tests when we couldn't reuse the originals self.reuseFailureQueue = Queue() self.testCount = 0 self.testsSubmitted = 0
import plugins, sys, logging, types from Queue import Queue, Empty from ordereddict import OrderedDict from threading import Lock plugins.addCategory("cancelled", "cancelled", "were cancelled before starting") class Cancelled(plugins.TestState): def __init__(self, briefText, freeText): plugins.TestState.__init__(self, "cancelled", briefText=briefText, freeText=freeText, \ started=1, completed=1, lifecycleChange="complete") # We're set up for running in a thread but we don't do so by default, for simplicity class BaseActionRunner(plugins.Responder, plugins.Observable): cancelFreeText = "Test run was cancelled before it had started" def __init__(self, optionMap, diag): plugins.Responder.__init__(self) plugins.Observable.__init__(self) self.optionMap = optionMap self.testQueue = Queue() self.exited = False self.allComplete = False self.lock = Lock() self.killSignal = None self.diag = diag self.lockDiag = logging.getLogger("locks") def notifyAdd(self, test, initial): if test.classId() == "test-case": self.diag.info("Adding test " + test.uniqueName)
def _getDescriptor(self, configEntry, configName): fromConfig = self.configMethod(configEntry, configName) if len(fromConfig) > 0: name, briefDesc, longDesc = plugins.commasplit(fromConfig) plugins.addCategory(name, briefDesc, longDesc) return name