""" 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
