def create(self, mode, argBag, hardCoded, legals, siteSpecificsObj):
try:
pnb = self.dict[mode](argBag, hardCoded, legals, siteSpecificsObj,
self.logger)
except KeyError:
msg = '%s unknown key %s, could not instantiate PathNameBuilder: ' % (
self.__class__.__name__, str(mode))
self.logger.error(msg)
raise RTTCodingError(msg)
except Exception, e:
msg = '%s Error constructing PathNameBuilder from key %s.\nException: %s\nTraceback:\n%s ' % (
self.__class__.__name__, str(mode), str(e), exc2string2())
self.logger.error(msg)
raise RTTCodingError(msg)
def pollLoopBody(self, jobMinders, launcher):
if self.operatorCloseDownTest():
self.logger.info('TestRun %s detected operator close down signal' %
self.name)
[m.queueOperatorCloseDown() for m in jobMinders]
launcher.launchNextUnlaunchedJob()
try:
[m.poll() for m in jobMinders]
except:
m = 'Error polling minder: %s ' % exc2string2()
self.logger.error(m)
self.logger.error(memstat())
self.logger.error('Garbage:\n%s' % gc.garbage)
self.logger.error('Collecting garbage...')
gc.collect()
self.logger.error('...Collected garbage')
raise RTTCodingError(m)
# the following print is done once when the minder goes to done
# the following is debug
# [m.printMethodTimes() for m in self.jobsActive]
toRemove = [m for m in jobMinders if m.isDone()]
self.mailer.collectStats(
toRemove) # info gathering for email sending purposes
[m.printMethodTimes() for m in toRemove]
[m.unlink() for m in toRemove]
[jobMinders.remove(m) for m in toRemove]
self.doneJobs += len(toRemove)
self.successfulJobs += len([j for j in toRemove if j.isSuccess()])
self.xmlConverter.pushData()
def createKits(cvsPackages, jobGroupConfig, logger):
try:
userDefinedKits = kitFromConfFile(cvsPackages)
except Exception, e:
m = 'createKits: Exception %s\nTraceback:\n' % (str(e), exc2string2())
logger.critical(m)
raise RTTCodingError(m)
class TestRunXMLConverterFactory(Factory):
def __init__(self, logger):
Factory.__init__(self, logger, self.__class__.__name__)
def create(self,
testRun,
packageResultsDir,
packageName,
packageTag,
containerPackage,
callBackConverter,
elementCreator,
textNodeCreator,
logger):
trClassName = testRun.__class__.__name__
# outputFile = os.path.join(packageResultsDir, packageName, 'rttpackageinfo.xml')
outputFile = os.path.join(packageResultsDir, 'rttpackageinfo.xml')
if trClassName == 'UnifiedConfigurationTestRun':
try:
converter = TestRunXMLConverter(outputFile, packageName, packageTag, containerPackage,
elementCreator, textNodeCreator, callBackConverter, logger)
except Exception, e:
m = 'Error creating TestRun: key %s\nException:\n%s\nTraceback:\n%s' % (trClassName, str(e), exc2string2())
raise RTTCodingError(m)
elif trClassName == 'FailureTestRun':
try:
converter = FailureTestRunXMLConverter(outputFile, packageName, packageTag, containerPackage,
elementCreator, textNodeCreator, callBackConverter, logger)
except Exception, e:
m = 'Error creating TestRun: key %s\nException:\n%s\nTraceback:\n%s' % (trClassName, str(e), exc2string2())
raise RTTCodingError(m)
def __init__(self, logDir, package, identifiedName, serialNumber,
elementCreator, textNodeCreator):
MethodTimer.__init__(self)
self.done = False
self.logDir = logDir
self.package = package
self.identifiedName = identifiedName
self.jobSerialNumber = serialNumber
self.elementCreator = elementCreator
self.textNodeCreator = textNodeCreator
self.jobGroup = None
self.rttPilotJob = False
self.rttATNJob = False
self.logger = None
self.makeLog()
self.logger.debug('MinderBase init')
self.stateEngine = None
try:
self.stateEngine = MinderStateEngineFactory(
self.logger).create(self)
except Exception, e:
msg = 'Error instantiating state engine:\n%s, Traceback:\n%s' % (
str(e), exc2string2())
self.logger.error(msg)
raise RTTCodingError(msg)
def superParser(paths, descFactory, minderFactory, logger):
"""Returns a list of all minders (RTT, RTTpilot and ATN)"""
jobListElement = paths.packageXMLfile['rtt/jobList[0]']
try:
atnElement = paths.packageXMLfile['atn[0]']
except IndexError:
atnElement = None
factory = JobsXMLReaderFactory(logger)
def makeMinders((mode, element), paths):
xmlReader = factory.create(mode, element, paths, descFactory)
try:
jobMinders = JobMaker(xmlReader, paths, descFactory, minderFactory,
logger).jobMinders
return jobMinders
except:
msg = 'Exception while parsing package xml file '
msg += 'mode: %s package %s \n' % (mode, paths.package)
msg += 'Traceback:\n%s' % exc2string2()
raise RTTCodingError(msg)
return []
def getJobGroupKit(jobGroup, jobGroupKits):
jobGroupKit = None
msg ='Could not obtain a kit with name '
try:
kit = jobGroupKits.kit(jobGroup)
except:
msg = 'getJobGroupKit: Failed to obtain a kit with name %s' % jobGroup
print msg
else:
return kit
if not jobGroupKit:
msg = 'getJobGroupKit: Attempting to obtain a kit with name %s' % jobGroup
print msg
jobGroup = 'Athena'+jobGroup
try:
kit = jobGroupKits.kit(jobGroup)
except:
msg = 'getJobGroupKit: Failed to obtain a kit with name %s\nTraceback:\n%s' % (jobGroup, exc2string2())
logger.error(msg)
raise RTTCodingError(msg)
else:
msg = 'getJobGroupKit: Succeeded in obtain a kit with name %s' % jobGroup
logger.debug(msg)
return kit
def poll(self):
"""
polls the state engine. If the state engine
changes state, report and re- poll
"""
m = '%s Start (Base) %s::poll() for %s' % (
nowSecs(), self.__class__.__name__, self.identifiedName)
self.logger.debug(m)
transition = self.stateEngine.poll()
if transition:
m = 'State transition detected (%s, %s): %s -> %s, calling back' % (
self.__class__.__name__, self.identifiedName,
self.stateEngine.pollEntryState,
self.stateEngine.pollExitState)
self.logger.info(m)
try:
self.xmlConverter.makeSummaryReport()
except:
m = 'Error on calling back to TestRun:\n%s' % exc2string2()
raise RTTCodingError(m)
# self.poll()
m = '%s End (Base) %s::poll() for %s' % (
nowSecs(), self.__class__.__name__, self.identifiedName)
self.logger.debug(m)
def makeJobGroupDirs(self, jobGroupDirectoryMaker):
try:
jobGroupDirectoryMaker.makeJobGroupDirs(self.runPath, self.resPath)
except:
msg = 'Exception making directories by %s traceback:\n%s' % (
self.identifiedName, exc2string2())
self.logger.error(msg)
raise RTTCodingError(msg)
def setupJobGroupDirs(self, jobGroupDirectoryMaker):
try:
jobGroupDirectoryMaker.setupRunDir(self)
except:
msg = 'Error setting up run directory by %s: TraceBack:\n%s' % (
self.identifiedName, exc2string2())
self.logger.warning(msg)
raise RTTCodingError(msg)
def create(self, descArgsForScripts, logger):
'Returns a ScriptWriter instance according to jobGroup'
jobGroup = descArgsForScripts.jobGroup
if jobGroup not in self.dict.keys():
msg = 'Error instantiating Script: unknown job jobGroup: %s ' % jobGroup
self.logger.error(msg)
print msg
raise RTTCodingError(msg)
argsForScripts = descArgsForScripts
argsForScripts.__dict__.update(self.argsForScripts.__dict__)
try:
script = self.dict[jobGroup](argsForScripts, logger)
except Exception, e:
m = 'Error constricting a runscript:\nException:\n%s\nTraceback:\n%s' % (str(e), exc2string2())
logger.error(m)
raise RTTCodingError(m)
def createMinder(self, argBag, jDescriptor):
self.logger.debug("Coming into createMinder: desc of type %s" %
jDescriptor.__class__.__name__)
key = self.makeKey(jDescriptor)
self.logger.debug("Made key, value is: %s" % key)
if not key: key = argBag.mode
self.logger.debug("Now have key, value is: %s" % key)
if key not in self.dict.keys():
m = 'MinderFactory: Unknown key for minder type. key: %s ' % key
self.logger.error(m)
raise RTTCodingError(m)
minderClass = self.dict[key]
msg = 'Instantiating a %s from a %s with name %s for package %s' % (
minderClass.__name__, jDescriptor.__class__.__name__,
jDescriptor.identifiedName, argBag.package)
self.logger.info(msg)
labels = [
'jobGroup', 'runPath', 'castorSvcClass', 'jobTransformCmd',
'jobOptions'
]
descArgsForScripts = makeArgBag(labels, jDescriptor)
try:
descArgsForScripts.athenaCommand = jDescriptor.athenaCommand()
except:
pass
# add in things jDescriptor _might_ have these will typically be collected
# by minders low in the Minder hierarchy
labels = ['outChainFiles', 'missingDatasets']
tempArgBag = makeArgBag(labels, jDescriptor)
argBag.__dict__.update(tempArgBag.__dict__)
try:
argBag.jobGroupKit = getJobGroupKit(jDescriptor.jobGroup,
self.jobGroupKits)
except Exception, e:
m = 'MinderFactory: Error extracting job group kit descriptor '
m += 'type: %s, job group: %s, error message: %s\nTraceback:%s' % (
jDescriptor.__class__.__name__, jDescriptor.jobGroup, str(e),
exc2string2())
# Not sure if this is really a coding error: might be a configuration problem.
# In any case, the exception is caught by the calling method
raise RTTCodingError(m)
def getReleaseDate(pathNameBuilder):
"""For a given release, get the stamp date from the directory on AFS,
or, for nightlies, from the link date if it is today's release."""
fileWithDate = str(pathNameBuilder.pathToFindReleaseDate())
date = getFileOrDirDateStamp(fileWithDate)
if not date.isValid():
m = 'InValidNICOSDateError %s' % str(date)
raise RTTCodingError(m)
return date
def __init__(self, maxVersion, destDir=None):
if not type(maxVersion) == IntType:
msg = 'VersionedFileSaver contructor arg not an int: %s ' % str(
maxVersion)
raise RTTCodingError(msg)
self.maxVersion = maxVersion
if destDir:
self.destDir = destDir
else:
self.destDir = os.getcwd()
def create(self):
'Returns a Commander instance according to mode'
if self.mode in self.dict.keys():
return self.dict[self.mode]()
else:
msg = 'CommanderFactory: Unknown mode: %s, could not instantiate a Commander\nTraceback:\n%s' % (
self.mode, exc2string2())
self.logger.error(msg)
raise RTTCodingError(msg)
def handleJobTransformJobs(self, jobs):
jobList=[]
for job in jobs:
try:
jobList.append(self.handleJobTransformJob(job))
except:
m = 'Error creating a JobTransform Descriptor. Traceback\n%s' % exc2string2()
logger.error(m)
raise RTTCodingError(m)
return jobList
def mkdirIfNew(directory, perm=02775):
"""Creates, with given permissions, the directory 'directory'
(only if it does not already exist)
This function originally used os.makedirs, but was rewritten
as makedirs was not setting the permission perm.
"""
perm = fixSBit(directory, perm)
if pathIsOwnedByMe(directory):
os.chmod(directory, perm)
return
else:
directory = os.path.normpath(directory)
head = str(directory)
start = head
if not isabs(head):
m = 'Cannot extend paths: start point must be absolute: %s' % head
logger.critical(m)
raise RTTCodingError(m)
tails = []
ncount = 0
while head != '/':
ncount += 1
if not ncount % 100:
logger.warning(
'Making directories for path %s, sub dir count huge %d' %
(start, ncount))
(head, tail) = os.path.split(head)
tails.append(tail)
tails.reverse()
for tail in tails:
head = os.path.join(head, tail)
if not os.path.exists(head):
try:
os.mkdir(head, perm)
changePerm(head, perm)
except Exception, e:
msg = 'Unable to make directory'
msg += '%s\n%s\nTraceBack:\n%s' % (str(head), str(e),
exc2string2())
logger.error(msg)
raise RTTCodingError(msg)
def poll(self):
# m = '%s Start %s::poll() for %s' % (nowSecs(), self.__class__.__name__, self.identifiedName)
# print m
try:
[m.poll() for m in self.minders]
except Exception, e:
msg = 'Minder %s: a contained minder threw an exception during poll\nTraceBack"\n%s' % (
self.identifiedName, exc2string2())
self.logger.error(msg)
raise RTTCodingError(msg)
def create(self, minder):
key = minder.__class__.__name__
try:
converter = self.dict[key](minder)
except Exception, e:
msg = 'MinderStateEngineFactory: Cannot create an XML converter for minder type %s Reason: %s\nTraceback\n%s ' % (
key, str(e), exc2string2())
print msg
raise RTTCodingError(msg)
def poll(self):
if self.currentMinder:
try:
self.currentMinder.poll()
except Exception, e:
msg = 'Minder: %s: Contained minder %s threw an exception during poll\nTraceBack\n%s' % (
self.identifiedName, self.currentMinder.identifiedName,
exc2string2())
self.logger.error(msg)
raise RTTCodingError(msg)
def create(self, type_):
dict = {'afs': AFSIOUtils, 'castor': CastorIOUtils}
try:
return dict[type_](self.logger)
except KeyError:
m = 'Unknown IO utils type %s, should be one of %s\n' % (
type_, dict.keys())
m += 'This illegal type was likely input through your top level cfg file.'
raise RTTInputError(m)
except Exception, e:
raise RTTCodingError(str(e))
def create(self, minder, state='queued'):
key = minder.__class__.__name__
try:
engine = self.dict[key](minder, state)
except:
msg = 'MinderStateEngineFactory: Cannot create a State engine for minder type %s:\nTraceback:\n%s' % (
key, exc2string2())
print msg
raise RTTCodingError(msg)
return engine
def create(self, descSetUpRunDirFn, minderClassName):
if minderClassName in self.dict.keys():
return self.dict[minderClassName](descSetUpRunDirFn, self.logger)
try:
directoryMaker = self.dict[minderClassName](descSetUpRunDirFn,
self.logger)
except KeyError:
msg = 'JobGroupDirectoryMakerFactory: key not in dictionary: %s' % minderClassName
raise RTTCodingError(msg)
except Exception, e:
'Error constructing DirectoryMaker from minder type %s \nException: %s\Traceback:\n%s' % (
minderClassName, str(e), exc2string2())
def kit(self, kitName):
kit = self.kitTree.getKit(kitName)
if kit == None:
if kitName == self.kitTree.topParentLabel:
logger.debug('Asked for a TopParent kit, returning None')
else:
m = 'No kit available with name '+kitName
logger.error(m)
raise RTTCodingError(m)
else:
logger.debug('Found kit with name '+kitName)
return kit
def fromPostProcessingRunning(self):
queryOK, isRunning = self.jobIsRunning()
if not queryOK:
msg = 'Unsuccesful query of a job running interactively'
raise RTTCodingError(msg)
if isRunning: return 'postProcessingRunning'
self.readTestResults()
self.copyKeepFiles()
self.cleanSpace()
return 'done'
def poll(self):
# m = '%s Start %s::poll() for %s' % (nowSecs(), self.__class__.__name__, self.identifiedName)
# print m
# minders instantiated on first poll
if not self.minder:
try:
self.makeMinder()
except:
msg = '%s error making inner minder Traceback:\n%s' % (
self.__class__.__name__, exc2string2())
raise RTTCodingError(msg)
self.minder.setSummaryCallBack(self.xmlConverter)
try:
self.minder.poll()
except Exception, e:
msg = '%s %s: inner minder %s threw an exception during poll\nTraceBack"\n%s' % (
self.__class__.__name__, self.identifiedName,
self.minder.identifiedName, exc2string2())
self.logger.error(msg)
raise RTTCodingError(msg)
def hasTop(self, nodes):
tops = [n for n in nodes if n.myLabel() == self.topLabel]
assert (len(tops) < 2)
if len(tops) == 0:
msg = 'No top node in Tree, raising exception\n'
msg += 'top node label %s \n' % self.topLabel
msg += formatCollection([n.myLabel() for n in nodes])
logger.error(msg)
raise RTTCodingError(msg)
top = tops[0]
top.parent = self.topParentLabel
def fromRunning(self):
queryOK, isRunning = self.jobIsRunning()
if not queryOK:
msg = 'Unsuccesful query of a job running interactively'
raise RTTCodingError(msg)
if isRunning: return 'running' # no state transition
self.fromRunningActions()
if self.doPostProcessing():
return 'postProcessingQueued'
return 'done'
def isType(instance, name):
"""name is a string. Determnes if class with name name is
in the class heirarchy of an instance"""
if not (type(name) is types.StringType):
m = 'isType: argument passed is of type %s, should be of type StringType' % name.__class__.__name__
raise RTTCodingError(m)
name = name.strip()
if instance.__class__.__name__ == name: return True
bases = [b.__name__ for b in instance.__class__.__bases__]
if name in bases: return True
return False
def checkConditions(self):
"""
check we have made the project build cmt requirements files
for now I am going to hardwire a lot of the code. This is less than
ideal as we are assuming what is done in other parts of the code
(UserStuffRetriever)
Need to make an USR in order to refind the cmt requirements
files...
"""
hExists = os.path.exists(self.cmtHomeDir)
msg = ''
if not hExists:
msg += 'cmtLinesProject no file: self.cmtHomeDir = %s\n' % self.cmtHomeDir
self.logger.error(msg)
raise RTTCodingError(msg)
