class AuxCacheUpdateTasks(CherryPyPeriodicTask):
"""
Updates Aux db update periodically. (i.e. TagCollector)
"""
def __init__(self, rest, config):
super(AuxCacheUpdateTasks, self).__init__(config)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url)
def setConcurrentTasks(self, config):
"""
sets the list of functions which
"""
self.concurrentTasks = [{
'func': self.updateCMSSW,
'duration': config.tagCollectDuration
}]
def updateCMSSW(self, config):
"""
gather active data statistics
"""
self.reqmgrAux.populateCMSSWVersion(config.tagcollect_url,
**config.tagcollect_args)
def __init__(self, msConfig, logger=None):
"""
Provides setup for MSTransferor and MSMonitor classes
:param config: MS service configuration
:param logger: logger object (optional)
"""
self.logger = getMSLogger(getattr(msConfig, 'verbose', False), logger)
self.msConfig = msConfig
self.logger.info("Configuration including default values:\n%s",
self.msConfig)
self.reqmgr2 = ReqMgr(self.msConfig['reqmgr2Url'], logger=self.logger)
self.reqmgrAux = ReqMgrAux(self.msConfig['reqmgr2Url'],
httpDict={'cacheduration': 1.0},
logger=self.logger)
# hard code it to production DBS otherwise PhEDEx subscribe API fails to match TMDB data
dbsUrl = "https://cmsweb.cern.ch/dbs/prod/global/DBSReader"
if usingRucio():
# FIXME: we cannot use Rucio in write mode yet
# self.rucio = Rucio(self.msConfig['rucioAccount'], configDict={"logger": self.logger})
self.phedex = PhEDEx(httpDict={'cacheduration': 0.5},
dbsUrl=dbsUrl,
logger=self.logger)
else:
self.phedex = PhEDEx(httpDict={'cacheduration': 0.5},
dbsUrl=dbsUrl,
logger=self.logger)
def __init__(self, msConfig, **kwargs):
"""
Provides setup for MSTransferor and MSMonitor classes
:param config: MS service configuration
:param kwargs: can be used to skip the initialization of specific services, such as:
logger: logger object
skipReqMgr: boolean to skip ReqMgr initialization
skipReqMgrAux: boolean to skip ReqMgrAux initialization
skipRucio: boolean to skip Rucio initialization
"""
self.logger = getMSLogger(getattr(msConfig, 'verbose', False), kwargs.get("logger"))
self.msConfig = msConfig
self.logger.info("Configuration including default values:\n%s", self.msConfig)
if not kwargs.get("skipReqMgr", False):
self.reqmgr2 = ReqMgr(self.msConfig['reqmgr2Url'], logger=self.logger)
if not kwargs.get("skipReqMgrAux", False):
self.reqmgrAux = ReqMgrAux(self.msConfig['reqmgr2Url'],
httpDict={'cacheduration': 1.0}, logger=self.logger)
self.phedex = None
self.rucio = None
if not kwargs.get("skipRucio", False):
self.rucio = Rucio(acct=self.msConfig['rucioAccount'],
hostUrl=self.msConfig['rucioUrl'],
authUrl=self.msConfig['rucioAuthUrl'],
configDict={"logger": self.logger, "user_agent": "wmcore-microservices"})
def __init__(self, rest, config):
super(CouchDBCleanup, self).__init__(config)
self.reqDB = RequestDBReader(config.reqmgrdb_url)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url, logger=self.logger)
# statuses that we want to keep the transfer documents
self.transferStatuses = [
"assigned", "staging", "staged", "acquired", "failed",
"running-open", "running-closed"
]
baseURL, acdcDB = splitCouchServiceURL(config.acdc_url)
self.acdcService = CouchService(url=baseURL, database=acdcDB)
def __init__(self, config):
"""
initialize properties specified from config
"""
BaseWorkerThread.__init__(self)
self.config = config
self.drainAPI = DrainStatusAPI()
self.condorAPI = PyCondorAPI()
self.agentConfig = {}
self.validSpeedDrainConfigKeys = [
'CondorPriority', 'NoJobRetries', 'EnableAllSites'
]
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
def __init__(self, rest, config):
super(BuildParentLock, self).__init__(config)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url, logger=self.logger)
self.dbs = DBS3Reader(config.dbs_url)
# cache of dbs lookups mapping input dataset to parent dataset
self.dbsLookupCache = {}
# set of of currently active datasets requiring parent dataset
self.inputDatasetCache = set()
self.reqDB = RequestDBReader(config.reqmgrdb_url)
self.filterKeys = [
'assignment-approved', 'assigned', 'staging', 'staged', 'failed',
'acquired', 'running-open', 'running-closed', 'force-complete',
'completed', 'closed-out'
]
def __init__(self, microConfig, uniConfig, logger=None):
"""
Runs the basic setup and initialization for the MS Transferor module
:param microConfig: microservice configuration
"""
self.msConfig = microConfig
self.uConfig = uniConfig
self.reqRecords = []
self.logger = getMSLogger(microConfig['verbose'], logger=logger)
self.reqmgr2 = ReqMgr(microConfig['reqmgrUrl'], logger=self.logger)
self.reqmgrAux = ReqMgrAux(microConfig['reqmgrUrl'], httpDict={'cacheduration': 60}, logger=self.logger)
# eventually will change it to Rucio
self.phedex = PhEDEx(httpDict={'cacheduration': 10 * 60},
dbsUrl=microConfig['dbsUrl'], logger=self.logger)
def __init__(self, config):
"""
initialize properties specified from config
"""
BaseWorkerThread.__init__(self)
self.config = config
self.drainAPI = DrainStatusAPI(config)
self.condorAPI = PyCondorAPI()
self.agentConfig = {}
self.previousConfig = {}
self.validSpeedDrainConfigKeys = [
'CondorPriority', 'NoJobRetries', 'EnableAllSites'
]
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
self.emailAlert = EmailAlert(config.EmailAlert.dictionary_())
self.condorStates = ("Running", "Idle")
def __init__(self, config):
"""
Initialise class members
"""
BaseWorkerThread.__init__(self)
self.config = config
myThread = threading.currentThread()
self.daoFactory = DAOFactory(package="WMCore.WMBS",
logger=myThread.logger,
dbinterface=myThread.dbi)
self.changeState = ChangeState(self.config)
if hasattr(self.config, "Tier0Feeder"):
self.reqAuxDB = None
self.maxRetries = self.config.ErrorHandler.maxRetries
else:
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
self.maxRetries = self.reqAuxDB.getWMAgentConfig(
self.config.Agent.hostName).get("MaxRetries")
if not isinstance(self.maxRetries, dict):
self.maxRetries = {'default': self.maxRetries}
if 'default' not in self.maxRetries:
raise ErrorHandlerException(
'Max retries for the default job type must be specified')
self.exitCodesNoRetry = []
self.maxProcessSize = getattr(self.config.ErrorHandler,
'maxProcessSize', 250)
self.maxFailTime = getattr(self.config.ErrorHandler, 'maxFailTime',
32 * 3600)
self.readFWJR = getattr(self.config.ErrorHandler, 'readFWJR', False)
self.passCodes = getattr(self.config.ErrorHandler, 'passExitCodes', [])
self.getJobs = self.daoFactory(classname="Jobs.GetAllJobs")
self.idLoad = self.daoFactory(classname="Jobs.LoadFromIDWithType")
self.loadAction = self.daoFactory(classname="Jobs.LoadForErrorHandler")
self.dataCollection = DataCollectionService(
url=config.ACDC.couchurl, database=config.ACDC.database)
return
class AuxCacheUpdateTasks(CherryPyPeriodicTask):
"""
Updates Aux db update periodically. (i.e. TagCollector)
"""
def __init__(self, rest, config):
super(AuxCacheUpdateTasks, self).__init__(config)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url, logger=self.logger)
self.mgr = RequestHandler()
def setConcurrentTasks(self, config):
"""
sets the list of functions which
"""
self.concurrentTasks = [{
'func': self.updateAuxiliarDocs,
'duration': config.tagCollectDuration
}]
def updateAuxiliarDocs(self, config):
"""
Update the central couch database with auxiliary documents
that need to be constanly updated whenever an update is
made at the data source
"""
self.logger.info("Updating auxiliary couch documents ...")
self.reqmgrAux.populateCMSSWVersion(config.tagcollect_url,
**config.tagcollect_args)
try:
data = self.mgr.getdata(config.unified_url,
params={},
headers={'Accept': 'application/json'})
data = json.loads(data)
except Exception as ex:
msg = "Failed to retrieve unified configuration from github. Error: %s" % str(
ex)
msg += "\nRetrying again in the next cycle"
self.logger.error(msg)
return
self.reqmgrAux.updateUnifiedConfig(data, docName="config")
def __init__(self, msConfig, **kwargs):
"""
Provides setup for MSTransferor and MSMonitor classes
:param config: MS service configuration
:param kwargs: can be used to skip the initialization of specific services, such as:
logger: logger object
skipReqMgr: boolean to skip ReqMgr initialization
skipReqMgrAux: boolean to skip ReqMgrAux initialization
skipRucio: boolean to skip Rucio initialization
skipPhEDEx: boolean to skip PhEDEx initialization
"""
self.logger = getMSLogger(getattr(msConfig, 'verbose', False),
kwargs.get("logger"))
self.msConfig = msConfig
self.logger.info("Configuration including default values:\n%s",
self.msConfig)
if not kwargs.get("skipReqMgr", False):
self.reqmgr2 = ReqMgr(self.msConfig['reqmgr2Url'],
logger=self.logger)
if not kwargs.get("skipReqMgrAux", False):
self.reqmgrAux = ReqMgrAux(self.msConfig['reqmgr2Url'],
httpDict={'cacheduration': 1.0},
logger=self.logger)
self.phedex = None
self.rucio = None
if self.msConfig.get('useRucio',
False) and not kwargs.get("skipRucio", False):
self.rucio = Rucio(acct=self.msConfig['rucioAccount'],
hostUrl=self.msConfig['rucioUrl'],
authUrl=self.msConfig['rucioAuthUrl'],
configDict={
"logger": self.logger,
"user_agent": "wmcore-microservices"
})
elif not kwargs.get("skipPhEDEx", False):
# hard code it to production DBS otherwise PhEDEx subscribe API fails to match TMDB data
dbsUrl = "https://cmsweb.cern.ch/dbs/prod/global/DBSReader"
self.phedex = PhEDEx(httpDict={'cacheduration': 0.5},
dbsUrl=dbsUrl,
logger=self.logger)
def __init__(self, config=None, logger=None):
"""
Setup a bunch of things, like:
* logger for this service
* initialize all the necessary service helpers
* fetch the unified configuration from central couch
* update the unified configuration with some deployment and default settings
* start both transfer and monitor threads
:param config: reqmgr2ms service configuration
:param logger:
"""
self.uConfig = {}
self.config = config
self.logger = getMSLogger(getattr(config, 'verbose', False), logger)
self._parseConfig(config)
self.logger.info("Configuration including default values:\n%s",
self.msConfig)
self.reqmgr2 = ReqMgr(self.msConfig['reqmgrUrl'], logger=self.logger)
self.reqmgrAux = ReqMgrAux(self.msConfig['reqmgrUrl'],
httpDict={'cacheduration': 60},
logger=self.logger)
# transferor has to look at workflows in assigned status
self.msTransferor = MSTransferor(self.msConfig,
"assigned",
logger=self.logger)
### Last but not least, get the threads started
thname = 'MSTransferor'
self.transfThread = start_new_thread(
thname, daemon, (self.transferor, 'assigned',
self.msConfig['interval'], self.logger))
self.logger.debug("### Running %s thread %s", thname,
self.transfThread.running())
thname = 'MSTransferorMonit'
self.monitThread = start_new_thread(
thname, daemon, (self.monitor, 'staging',
self.msConfig['interval'] * 2, self.logger))
self.logger.debug("+++ Running %s thread %s", thname,
self.monitThread.running())
def __init__(self, config):
"""
initialize properties specified from config
"""
BaseWorkerThread.__init__(self)
self.config = config
self.drainAPI = DrainStatusAPI(config)
self.condorAPI = PyCondorAPI()
self.agentConfig = {}
self.validSpeedDrainConfigKeys = ['CondorPriority', 'NoJobRetries', 'EnableAllSites']
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
class AuxCacheUpdateTasks(CherryPyPeriodicTask):
"""
Updates Aux db update periodically. (i.e. TagCollector)
"""
def __init__(self, rest, config):
super(AuxCacheUpdateTasks, self).__init__(config)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url, logger=self.logger)
def setConcurrentTasks(self, config):
"""
sets the list of functions which
"""
self.concurrentTasks = [{'func': self.updateCMSSW, 'duration': config.tagCollectDuration}]
def updateCMSSW(self, config):
"""
gather active data statistics
"""
self.reqmgrAux.populateCMSSWVersion(config.tagcollect_url, **config.tagcollect_args)
self.logger.info("Updated CMSSW versions in the auxiliar db")
def __init__(self, config):
"""
Initialise class members
"""
BaseWorkerThread.__init__(self)
self.config = config
myThread = threading.currentThread()
self.daoFactory = DAOFactory(package="WMCore.WMBS",
logger=myThread.logger,
dbinterface=myThread.dbi)
self.changeState = ChangeState(self.config)
if hasattr(self.config, "Tier0Feeder"):
self.reqAuxDB = None
self.maxRetries = self.config.ErrorHandler.maxRetries
else:
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
self.exitCodesNoRetry = []
self.maxProcessSize = getattr(self.config.ErrorHandler,
'maxProcessSize', 250)
self.maxFailTime = getattr(self.config.ErrorHandler, 'maxFailTime',
32 * 3600)
self.readFWJR = getattr(self.config.ErrorHandler, 'readFWJR', False)
self.passCodes = getattr(self.config.ErrorHandler, 'passExitCodes', [])
self.getJobs = self.daoFactory(classname="Jobs.GetAllJobs")
self.idLoad = self.daoFactory(classname="Jobs.LoadFromIDWithType")
self.loadAction = self.daoFactory(classname="Jobs.LoadForErrorHandler")
self.dataCollection = DataCollectionService(
url=config.ACDC.couchurl, database=config.ACDC.database)
self.setupComponentParam()
return
def main():
"Main function"
optmgr = OptionParser()
opts = optmgr.parser.parse_args()
verbose = int(opts.verbose)
logger = None
mgr = None
if verbose:
logger = logging.getLogger('parse_campaign')
logger.setLevel(logging.DEBUG)
logging.basicConfig()
if opts.url:
key = os.getenv('X509_USER_KEY', '')
cert = os.getenv('X509_USER_CERT', '')
proxy = os.getenv('X509_USER_PROXY', '')
if proxy and not cert:
cert = proxy
key = proxy
hdict = {'cert': cert, 'key': key, 'pycurl': True}
mgr = ReqMgrAux(opts.url, hdict, logger=logger)
if opts.dburi:
conn = MongoClient(host=opts.dburi)
dbname = opts.dbname
dbcoll = opts.dbcoll
if verbose:
print("### read data from '%s', %s/%s" %
(opts.dburi, dbname, dbcoll))
data = [r for r in conn[dbname][dbcoll].find()]
else:
fin = opts.fin
if verbose:
print("### read data from '%s'" % fin)
with open(fin, 'r') as istream:
data = []
for key, val in json.load(istream).items():
rec = {'name': key}
rec.update(val)
data.append(rec)
rawRecords = parse(data, verbose)
output = [] # in case we want to dump all records to a json file
for rec in process(rawRecords):
output.append(rec)
print(json.dumps(rec))
upload(mgr, rec)
if opts.fout:
print("Saving all %d unique campaign records to: %s\n" %
(len(output), opts.fout))
with open(opts.fout, "w") as jo:
json.dump(output, jo, indent=2)
def __init__(self, config):
"""
Initialise class members
"""
BaseWorkerThread.__init__(self)
self.config = config
myThread = threading.currentThread()
self.daoFactory = DAOFactory(package="WMCore.WMBS",
logger=myThread.logger,
dbinterface=myThread.dbi)
self.changeState = ChangeState(self.config)
if hasattr(self.config, "Tier0Feeder"):
self.reqAuxDB = None
self.maxRetries = self.config.ErrorHandler.maxRetries
else:
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
self.maxRetries = self.reqAuxDB.getWMAgentConfig(self.config.Agent.hostName).get("MaxRetries")
if not isinstance(self.maxRetries, dict):
self.maxRetries = {'default': self.maxRetries}
if 'default' not in self.maxRetries:
raise ErrorHandlerException('Max retries for the default job type must be specified')
self.exitCodesNoRetry = []
self.maxProcessSize = getattr(self.config.ErrorHandler, 'maxProcessSize', 250)
self.maxFailTime = getattr(self.config.ErrorHandler, 'maxFailTime', 32 * 3600)
self.readFWJR = getattr(self.config.ErrorHandler, 'readFWJR', False)
self.passCodes = getattr(self.config.ErrorHandler, 'passExitCodes', [])
self.getJobs = self.daoFactory(classname="Jobs.GetAllJobs")
self.idLoad = self.daoFactory(classname="Jobs.LoadFromIDWithType")
self.loadAction = self.daoFactory(classname="Jobs.LoadForErrorHandler")
self.dataCollection = DataCollectionService(url=config.ACDC.couchurl,
database=config.ACDC.database)
return
def __init__(self, config):
"""
Initialise class members
"""
BaseWorkerThread.__init__(self)
self.config = config
myThread = threading.currentThread()
self.daoFactory = DAOFactory(package="WMCore.WMBS",
logger=myThread.logger,
dbinterface=myThread.dbi)
self.changeState = ChangeState(self.config)
if hasattr(self.config, "Tier0Feeder"):
self.reqAuxDB = None
self.maxRetries = self.config.ErrorHandler.maxRetries
else:
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
self.exitCodesNoRetry = []
self.maxProcessSize = getattr(self.config.ErrorHandler, 'maxProcessSize', 250)
self.maxFailTime = getattr(self.config.ErrorHandler, 'maxFailTime', 32 * 3600)
self.readFWJR = getattr(self.config.ErrorHandler, 'readFWJR', False)
self.passCodes = getattr(self.config.ErrorHandler, 'passExitCodes', [])
self.getJobs = self.daoFactory(classname="Jobs.GetAllJobs")
self.idLoad = self.daoFactory(classname="Jobs.LoadFromIDWithType")
self.loadAction = self.daoFactory(classname="Jobs.LoadForErrorHandler")
self.dataCollection = DataCollectionService(url=config.ACDC.couchurl,
database=config.ACDC.database)
self.setupComponentParam()
return
def main():
"Main function"
optmgr = OptionParser()
opts = optmgr.parser.parse_args()
verbose = int(opts.verbose)
logger = None
mgr = None
inputWMCore = False
if verbose:
logger = logging.getLogger('parse_campaign')
logger.setLevel(logging.DEBUG)
logging.basicConfig()
if opts.url:
key = os.getenv('X509_USER_KEY', '')
cert = os.getenv('X509_USER_CERT', '')
proxy = os.getenv('X509_USER_PROXY', '')
if proxy and not cert:
cert = proxy
key = proxy
hdict = {'cert': cert, 'key': key, 'pycurl': True}
mgr = ReqMgrAux(opts.url, hdict, logger=logger)
if opts.dburi:
conn = MongoClient(host=opts.dburi)
dbname = opts.dbname
dbcoll = opts.dbcoll
if verbose:
print("### read data from '%s', %s/%s" %
(opts.dburi, dbname, dbcoll))
data = [r for r in conn[dbname][dbcoll].find()]
elif opts.fin:
fin = opts.fin
if verbose:
print("### read data from '%s'" % fin)
data = []
with open(fin, 'r') as istream:
campData = json.load(istream)
if isinstance(campData, dict):
# then it's a Unified-like campaign schema
for key, val in campData.items():
rec = {'name': key}
rec.update(val)
data.append(rec)
elif isinstance(campData, list):
# then the input file has WMCore-like campaign schema
print("Found %d campaigns in the input file." % len(campData))
data = campData
inputWMCore = True
if not inputWMCore:
data = parse(data, verbose)
output = [] # in case we want to dump all records to a json file
for rec in process(data):
output.append(rec)
upload(mgr, rec)
if opts.testcamp:
insertTestCampaigns(mgr)
if opts.fout:
print("Saving all %d unique campaign records to: %s\n" %
(len(output), opts.fout))
with open(opts.fout, "w") as jo:
json.dump(output, jo, indent=2)
class MSCore(object):
"""
This class provides core functionality for
MSTransferor, MSMonitor, MSOutput. MSRuleCleaner classes.
"""
def __init__(self, msConfig, **kwargs):
"""
Provides setup for MSTransferor and MSMonitor classes
:param config: MS service configuration
:param kwargs: can be used to skip the initialization of specific services, such as:
logger: logger object
skipReqMgr: boolean to skip ReqMgr initialization
skipReqMgrAux: boolean to skip ReqMgrAux initialization
skipRucio: boolean to skip Rucio initialization
"""
self.logger = getMSLogger(getattr(msConfig, 'verbose', False), kwargs.get("logger"))
self.msConfig = msConfig
self.logger.info("Configuration including default values:\n%s", self.msConfig)
if not kwargs.get("skipReqMgr", False):
self.reqmgr2 = ReqMgr(self.msConfig['reqmgr2Url'], logger=self.logger)
if not kwargs.get("skipReqMgrAux", False):
self.reqmgrAux = ReqMgrAux(self.msConfig['reqmgr2Url'],
httpDict={'cacheduration': 1.0}, logger=self.logger)
self.phedex = None
self.rucio = None
if not kwargs.get("skipRucio", False):
self.rucio = Rucio(acct=self.msConfig['rucioAccount'],
hostUrl=self.msConfig['rucioUrl'],
authUrl=self.msConfig['rucioAuthUrl'],
configDict={"logger": self.logger, "user_agent": "wmcore-microservices"})
def unifiedConfig(self):
"""
Fetches the unified configuration
:return: unified configuration content
"""
res = self.reqmgrAux.getUnifiedConfig(docName="config")
if res:
if isinstance(res, list):
return res[0]
return res
else:
return {}
def change(self, reqName, reqStatus, prefix='###'):
"""
Update the request status in ReqMgr2
"""
try:
if self.msConfig['enableStatusTransition']:
self.logger.info('%s updating %s status to: %s', prefix, reqName, reqStatus)
self.reqmgr2.updateRequestStatus(reqName, reqStatus)
else:
self.logger.info('DRY-RUN:: %s updating %s status to: %s', prefix, reqName, reqStatus)
except Exception as err:
self.logger.exception("Failed to change request status. Error: %s", str(err))
def updateReportDict(self, reportDict, keyName, value):
"""
Provided a key name and value, validate the key name
and update the report dictionary if it passes the validation
:param reportDict: dictionary with a summary of the service
:param keyName: string with the key name in the report
:param value: string/integer value with the content of a metric
:return: the updated dictionary
"""
if keyName not in reportDict:
self.logger.error("Report metric '%s' is not supported", keyName)
else:
reportDict[keyName] = value
return reportDict
class DrainStatusPoller(BaseWorkerThread):
"""
Collects information related to the agent drain status
"""
# class variable that contains drain statistics
drainStats = {}
def __init__(self, config):
"""
initialize properties specified from config
"""
BaseWorkerThread.__init__(self)
self.config = config
self.drainAPI = DrainStatusAPI()
self.condorAPI = PyCondorAPI()
self.agentConfig = {}
self.validSpeedDrainConfigKeys = [
'CondorPriority', 'NoJobRetries', 'EnableAllSites'
]
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
@timeFunction
def algorithm(self, parameters):
"""
Update drainStats if agent is in drain mode
"""
logging.info("Running agent drain algorithm...")
self.agentConfig = self.reqAuxDB.getWMAgentConfig(
self.config.Agent.hostName)
if isDrainMode(self.config):
# check to see if the agent hit any speed drain thresholds
thresholdsHit = self.checkSpeedDrainThresholds()
if thresholdsHit:
logging.info("Updating agent configuration for speed drain...")
self.updateAgentSpeedDrainConfig(thresholdsHit)
try:
DrainStatusPoller.drainStats = self.drainAPI.collectDrainInfo()
logging.info("Finished collecting agent drain status.")
logging.info("Drain stats: " +
str(DrainStatusPoller.drainStats))
except Exception as ex:
msg = "Error occurred, will retry later:\n"
msg += str(ex)
logging.exception(msg)
else:
logging.info(
"Agent not in drain mode. Resetting flags and skipping drain check..."
)
self.resetAgentSpeedDrainConfig()
@classmethod
def getDrainInfo(cls):
"""
Return drainStats class variable
"""
return cls.drainStats
def updateAgentSpeedDrainConfig(self, thresholdsHit):
"""
Takes a list of speed drain configuration keys and updates the agent configuration
"""
updateConfig = False
condorPriorityFlag = False
speedDrainConfig = self.agentConfig.get("SpeedDrainConfig")
if 'CondorPriority' in thresholdsHit:
logging.info(
"Bumping condor job priority to 999999 for Production/Processing pending jobs."
)
self.condorAPI.editCondorJobs(
"JobStatus=?=1 && (CMS_JobType =?= \"Production\" || CMS_JobType =?= \"Processing\")",
"JobPrio", "999999")
condorPriorityFlag = True
if condorPriorityFlag != speedDrainConfig['CondorPriority']['Enabled']:
# CondorPriority setting is irreversible so the flag only indicates weather
# priority is increased or not. It is not checked by other components
logging.info("Enabling CondorPriority flag.")
speedDrainConfig['CondorPriority']['Enabled'] = condorPriorityFlag
updateConfig = True
if 'NoJobRetries' in thresholdsHit:
logging.info(
"Enabling NoJobRetries flag: Error Handler won't retry the jobs"
)
# ErrorHandler will pick this up and set max retries to 0
speedDrainConfig['NoJobRetries']['Enabled'] = True
updateConfig = True
if 'EnableAllSites' in thresholdsHit:
logging.info(
"Enabling EnableAllSites flag: Updating agent to submit to all sites."
)
# setting this value to True makes JobSubmitterPoller ignore site status
speedDrainConfig['EnableAllSites']['Enabled'] = True
updateConfig = True
# update the aux db speed drain config with any changes
if updateConfig:
self.reqAuxDB.updateAgentConfig(self.config.Agent.hostName,
"SpeedDrainMode", True)
self.reqAuxDB.updateAgentConfig(self.config.Agent.hostName,
"SpeedDrainConfig",
speedDrainConfig)
return
def resetAgentSpeedDrainConfig(self):
"""
resetting SpeedDrainMode to False and SpeedDrainiConfig Enabled to False
"""
if self.agentConfig.get("SpeedDrainMode"):
self.reqAuxDB.updateAgentConfig(self.config.Agent.hostName,
"SpeedDrainMode", False)
speedDrainConfig = self.agentConfig.get("SpeedDrainConfig")
for key, v in speedDrainConfig.items():
if key in self.validSpeedDrainConfigKeys and v['Enabled']:
speedDrainConfig[key]['Enabled'] = False
self.reqAuxDB.updateAgentConfig(self.config.Agent.hostName,
"SpeedDrainConfig",
speedDrainConfig)
return
def checkSpeedDrainThresholds(self):
"""
Check the current number of jobs in Condor and create a list of agent configuration parameters
that need updated for speed draining
"""
enableKeys = []
# get the current speed drain status
speedDrainConfig = self.agentConfig.get("SpeedDrainConfig")
# get condor jobs
jobs = self.condorAPI.getCondorJobs("", [])
if jobs is None:
logging.warning(
"There was an error querying the schedd. Not checking speed drain thresholds."
)
return []
# loop through the speed drain configuration and make a list of what thresholds have been hit
for k, v in speedDrainConfig.items():
# make sure keys in the speed drain config are valid
if k in self.validSpeedDrainConfigKeys and isinstance(
v['Threshold'], int) and isinstance(v['Enabled'], bool):
# we always want to apply the condor priority change if the threshold is hit
if not v['Enabled'] or k == 'CondorPriority':
logging.info("Checking speed drain threshold for %s. ", k)
if len(jobs) < v['Threshold']:
logging.info(
"Agent will update speed drain configuration for %s. ",
k)
enableKeys.append(k)
else:
logging.warning(
"Speed drain configuration error for %s. Please check aux db contents.",
k)
return enableKeys
class DrainStatusPoller(BaseWorkerThread):
"""
Collects information related to the agent drain status
"""
# class variable that contains drain statistics
drainStats = {}
def __init__(self, config):
"""
initialize properties specified from config
"""
BaseWorkerThread.__init__(self)
self.config = config
self.drainAPI = DrainStatusAPI(config)
self.condorAPI = PyCondorAPI()
self.agentConfig = {}
self.validSpeedDrainConfigKeys = ['CondorPriority', 'NoJobRetries', 'EnableAllSites']
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
@timeFunction
def algorithm(self, parameters):
"""
Update drainStats if agent is in drain mode
"""
logging.info("Running agent drain algorithm...")
self.agentConfig = self.reqAuxDB.getWMAgentConfig(self.config.Agent.hostName)
if not self.agentConfig:
logging.error("Failed to fetch agent configuration from the auxiliary DB")
return
if isDrainMode(self.config):
# check to see if the agent hit any speed drain thresholds
thresholdsHit = self.checkSpeedDrainThresholds()
if thresholdsHit:
logging.info("Updating agent configuration for speed drain...")
self.updateAgentSpeedDrainConfig(thresholdsHit)
# now collect drain statistics
try:
DrainStatusPoller.drainStats = self.drainAPI.collectDrainInfo()
logging.info("Finished collecting agent drain status.")
logging.info("Drain stats: " + str(DrainStatusPoller.drainStats))
except Exception as ex:
msg = "Error occurred, will retry later:\n"
msg += str(ex)
logging.exception(msg)
else:
logging.info("Agent not in drain mode. Resetting flags and skipping drain check...")
self.resetAgentSpeedDrainConfig()
@classmethod
def getDrainInfo(cls):
"""
Return drainStats class variable
"""
return cls.drainStats
def updateAgentSpeedDrainConfig(self, thresholdsHit):
"""
Takes a list of speed drain configuration keys and updates the agent configuration
"""
updateConfig = False
condorPriorityFlag = False
speedDrainConfig = self.agentConfig.get("SpeedDrainConfig")
if 'CondorPriority' in thresholdsHit:
logging.info("Bumping condor job priority to 999999 for Production/Processing pending jobs.")
self.condorAPI.editCondorJobs(
"JobStatus=?=1 && (CMS_JobType =?= \"Production\" || CMS_JobType =?= \"Processing\")",
"JobPrio", "999999")
condorPriorityFlag = True
if condorPriorityFlag != speedDrainConfig['CondorPriority']['Enabled']:
# CondorPriority setting is irreversible so the flag only indicates weather
# priority is increased or not. It is not checked by other components
logging.info("Enabling CondorPriority flag.")
speedDrainConfig['CondorPriority']['Enabled'] = condorPriorityFlag
updateConfig = True
if 'NoJobRetries' in thresholdsHit:
logging.info("Enabling NoJobRetries flag: Error Handler won't retry the jobs")
# ErrorHandler will pick this up and set max retries to 0
speedDrainConfig['NoJobRetries']['Enabled'] = True
updateConfig = True
if 'EnableAllSites' in thresholdsHit:
logging.info("Enabling EnableAllSites flag: Updating agent to submit to all sites.")
# setting this value to True makes JobSubmitterPoller ignore site status
speedDrainConfig['EnableAllSites']['Enabled'] = True
updateConfig = True
# update the aux db speed drain config with any changes
if updateConfig:
self.reqAuxDB.updateAgentConfig(self.config.Agent.hostName, "SpeedDrainMode", True)
self.reqAuxDB.updateAgentConfig(self.config.Agent.hostName, "SpeedDrainConfig", speedDrainConfig)
return
def resetAgentSpeedDrainConfig(self):
"""
resetting SpeedDrainMode to False and SpeedDrainiConfig Enabled to False
"""
if self.agentConfig.get("SpeedDrainMode"):
self.reqAuxDB.updateAgentConfig(self.config.Agent.hostName, "SpeedDrainMode", False)
speedDrainConfig = self.agentConfig.get("SpeedDrainConfig")
for key, v in speedDrainConfig.items():
if key in self.validSpeedDrainConfigKeys and v['Enabled']:
speedDrainConfig[key]['Enabled'] = False
self.reqAuxDB.updateAgentConfig(self.config.Agent.hostName, "SpeedDrainConfig", speedDrainConfig)
return
def checkSpeedDrainThresholds(self):
"""
Check the current number of jobs in Condor and create a list of agent configuration parameters
that need updated for speed draining
"""
enableKeys = []
# get the current speed drain status
speedDrainConfig = self.agentConfig.get("SpeedDrainConfig")
# get condor jobs
jobs = self.condorAPI.getCondorJobs("", [])
if jobs is None:
logging.warning("There was an error querying the schedd. Not checking speed drain thresholds.")
return []
# loop through the speed drain configuration and make a list of what thresholds have been hit
for k, v in speedDrainConfig.items():
# make sure keys in the speed drain config are valid
if k in self.validSpeedDrainConfigKeys and isinstance(v['Threshold'], int) and isinstance(v['Enabled'], bool):
# we always want to apply the condor priority change if the threshold is hit
if not v['Enabled'] or k == 'CondorPriority':
logging.info("Checking speed drain threshold for %s. ", k)
if len(jobs) < v['Threshold']:
logging.info("Agent will update speed drain configuration for %s. ", k)
enableKeys.append(k)
else:
logging.warning("Speed drain configuration error for %s. Please check aux db contents.", k)
return enableKeys
def __init__(self, config):
BaseWorkerThread.__init__(self)
myThread = threading.currentThread()
self.config = config
#DAO factory for WMBS objects
self.daoFactory = DAOFactory(package="WMCore.WMBS",
logger=logging,
dbinterface=myThread.dbi)
#Libraries
self.resourceControl = ResourceControl()
self.changeState = ChangeState(self.config)
self.bossAir = BossAirAPI(config=self.config)
self.hostName = self.config.Agent.hostName
self.repollCount = getattr(self.config.JobSubmitter, 'repollCount',
10000)
self.maxJobsPerPoll = int(
getattr(self.config.JobSubmitter, 'maxJobsPerPoll', 1000))
self.maxJobsThisCycle = self.maxJobsPerPoll # changes as per schedd limit
self.cacheRefreshSize = int(
getattr(self.config.JobSubmitter, 'cacheRefreshSize', 30000))
self.skipRefreshCount = int(
getattr(self.config.JobSubmitter, 'skipRefreshCount', 20))
self.packageSize = getattr(self.config.JobSubmitter, 'packageSize',
500)
self.collSize = getattr(self.config.JobSubmitter, 'collectionSize',
self.packageSize * 1000)
self.maxTaskPriority = getattr(self.config.BossAir, 'maxTaskPriority',
1e7)
self.condorFraction = 0.75 # update during every algorithm cycle
self.condorOverflowFraction = 0.2
self.ioboundTypes = ('LogCollect', 'Merge', 'Cleanup', 'Harvesting')
# Additions for caching-based JobSubmitter
self.cachedJobIDs = set()
self.cachedJobs = {}
self.jobDataCache = {}
self.jobsToPackage = {}
self.sandboxPackage = {}
self.locationDict = {}
self.taskTypePrioMap = {}
self.drainSites = set()
self.abortSites = set()
self.refreshPollingCount = 0
try:
if not getattr(self.config.JobSubmitter, 'submitDir', None):
self.config.JobSubmitter.submitDir = self.config.JobSubmitter.componentDir
self.packageDir = os.path.join(self.config.JobSubmitter.submitDir,
'packages')
if not os.path.exists(self.packageDir):
os.makedirs(self.packageDir)
except OSError as ex:
msg = "Error while trying to create packageDir %s\n!"
msg += str(ex)
logging.error(msg)
logging.debug("PackageDir: %s", self.packageDir)
logging.debug("Config: %s", config)
raise JobSubmitterPollerException(msg)
# Now the DAOs
self.listJobsAction = self.daoFactory(
classname="Jobs.ListForSubmitter")
self.setLocationAction = self.daoFactory(classname="Jobs.SetLocation")
self.locationAction = self.daoFactory(
classname="Locations.GetSiteInfo")
self.setFWJRPathAction = self.daoFactory(classname="Jobs.SetFWJRPath")
self.listWorkflows = self.daoFactory(
classname="Workflow.ListForSubmitter")
# Keep a record of the thresholds in memory
self.currentRcThresholds = {}
self.useReqMgrForCompletionCheck = getattr(
self.config.TaskArchiver, 'useReqMgrForCompletionCheck', True)
if self.useReqMgrForCompletionCheck:
# only set up this when reqmgr is used (not Tier0)
self.reqmgr2Svc = ReqMgr(self.config.General.ReqMgr2ServiceURL)
self.abortedAndForceCompleteWorkflowCache = self.reqmgr2Svc.getAbortedAndForceCompleteRequestsFromMemoryCache(
)
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
else:
# Tier0 Case - just for the clarity (This private variable shouldn't be used
self.abortedAndForceCompleteWorkflowCache = None
return
class MSTransferor(object):
def __init__(self, microConfig, status, logger=None):
"""
Runs the basic setup and initialization for the MS Transferor module
:param microConfig: microservice configuration
"""
self.msConfig = microConfig
self.status = status
self.uConfig = {}
self.logger = getMSLogger(microConfig['verbose'], logger=logger)
self.reqmgr2 = ReqMgr(microConfig['reqmgrUrl'], logger=self.logger)
self.reqmgrAux = ReqMgrAux(microConfig['reqmgrUrl'],
httpDict={'cacheduration': 60},
logger=self.logger)
# eventually will change it to Rucio
self.phedex = PhEDEx(httpDict={'cacheduration': 10 * 60},
dbsUrl=microConfig['dbsUrl'],
logger=self.logger)
def prep(self):
"""
Runs any preparation tasks before executing the actual algorithm.
For now:
* fetches the unified configuration
:return: False if it fail to run this action, otherwise True
"""
self.uConfig = self.reqmgrAux.getUnifiedConfig(docName="config")
return bool(self.uConfig)
def execute(self):
"""
Executes the whole transferor logic
:param reqStatus: request status to that matters for this module
:return:
"""
if not self.prep():
self.logger.warning(
"Failed to fetch the latest unified config. Skipping this cycle"
)
return
self.uConfig = self.uConfig[0]
requestRecords = []
try:
# get requests from ReqMgr2 data-service for given status
requests = self.reqmgr2.getRequestByStatus([self.status],
detail=True)
if requests:
requests = requests[0]
self.logger.info("### transferor found %s requests in '%s' state",
len(requests), self.status)
if requests:
for _, wfData in requests.iteritems():
requestRecords.append(self.requestRecord(wfData))
except Exception as err:
self.logger.exception('### transferor error: %s', str(err))
if not requestRecords:
return
try:
reqInfo = RequestInfo(self.msConfig, self.uConfig, self.logger)
for reqSlice in grouper(requestRecords, 50):
reqResults = reqInfo(reqSlice)
self.logger.info("%d requests completely processed.",
len(reqResults))
self.logger.info(
"Working on the data subscription and status change...")
# process all requests
for req in reqResults:
reqName = req['name']
# perform transfer
tid = self.transferRequest(req)
if tid:
# Once all transfer requests were successfully made, update: assigned -> staging
self.logger.debug(
"### transfer request for %s successfull", reqName)
self.change(req, 'staging', '### transferor')
# if there is nothing to be transferred (no input at all),
# then update the request status once again staging -> staged
# self.change(req, 'staged', '### transferor')
except Exception as err: # general error
self.logger.exception('### transferor error: %s', str(err))
def post(self):
"""
Runs any post tasks before exiting the execution cycle
:return:
"""
pass
def requestRecord(self, wfData):
"""
Selects only important information for a request dictionary
Returns: a dictionary
"""
datasets = []
if "TaskChain" in wfData or "StepChain" in wfData:
innerDicts = []
for i in range(
1,
wfData.get("TaskChain", wfData.get("StepChain")) + 1):
innerDicts.append(
wfData.get("Task%d" % i, wfData.get("Step%d" % i)))
else:
# ReReco and DQMHarvesting
innerDicts = [wfData]
for item in innerDicts:
for key in ['InputDataset', 'MCPileup', 'DataPileup']:
dataset = item.get(key)
if dataset:
datasets.append({'type': key, 'name': dataset})
return {
'name': wfData.get('RequestName'),
'reqStatus': wfData.get('RequestStatus'),
'SiteWhiteList': wfData.get('SiteWhitelist', []),
'SiteBlackList': wfData.get('SiteBlacklist', []),
'datasets': datasets,
'campaign': []
}
def transferRequest(self, req):
"Send request to Phedex and return status of request subscription"
datasets = req.get('datasets', [])
sites = req.get('sites', [])
if datasets and sites:
self.logger.debug("### creating subscription for: %s",
pformat(req))
subscription = PhEDExSubscription(datasets, sites,
self.msConfig['group'])
# TODO: implement how to get transfer id
tid = hashlib.md5(str(subscription)).hexdigest()
# TODO: when ready enable submit subscription step
# self.phedex.subscribe(subscription)
return tid
def change(self, req, reqStatus, prefix='###'):
"""
Change request status, internally it is done via PUT request to ReqMgr2:
curl -X PUT -H "Content-Type: application/json" \
-d '{"RequestStatus":"staging", "RequestName":"bla-bla"}' \
https://xxx.yyy.zz/reqmgr2/data/request
"""
self.logger.debug('%s updating %s status to %s', prefix, req['name'],
reqStatus)
try:
if not self.msConfig['readOnly']:
self.reqmgr2.updateRequestStatus(req['name'], reqStatus)
except Exception as err:
self.logger.exception("Failed to change request status. Error: %s",
str(err))
def __init__(self, rest, config):
super(AuxCacheUpdateTasks, self).__init__(config)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url, logger=self.logger)
class CouchDBCleanup(CherryPyPeriodicTask):
def __init__(self, rest, config):
super(CouchDBCleanup, self).__init__(config)
self.reqDB = RequestDBReader(config.reqmgrdb_url)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url, logger=self.logger)
# statuses that we want to keep the transfer documents
self.transferStatuses = [
"assigned", "staging", "staged", "acquired", "failed",
"running-open", "running-closed"
]
baseURL, acdcDB = splitCouchServiceURL(config.acdc_url)
self.acdcService = CouchService(url=baseURL, database=acdcDB)
def setConcurrentTasks(self, config):
"""
sets the list of functions which
"""
self.concurrentTasks = [{
'func': self.acdcCleanup,
'duration': config.acdcCleanDuration
}, {
'func': self.auxCouchCleanup,
'duration': config.auxCleanDuration
}]
def auxCouchCleanup(self, config):
"""
Cleanup TRANSFER documents from the reqmgr_auxiliary CouchDB.
The list of status can be expanded in the future
"""
self.logger.info("Fetching TRANSFER documents from CouchDB...")
transferDocs = self.reqmgrAux.getTransferInfo("ALL_DOCS")
if not transferDocs:
self.logger.info(
" there are no transfer documents in the database.")
return
auxDocs = []
for row in transferDocs:
auxDocs.append(row['workflowName'])
results = self.reqDB._getCouchView("bystatus", {},
self.transferStatuses)
activeRequests = []
for row in results["rows"]:
activeRequests.append(row["id"])
# now find transfer docs that are not active in the system
transferDocs = []
for transferDoc in auxDocs:
if transferDoc not in activeRequests:
transferDocs.append(transferDoc)
self.logger.info("Found %d transfer documents to delete",
len(transferDocs))
for wflowName in transferDocs:
self.logger.info("Deleting transfer document: %s", wflowName)
try:
self.reqmgrAux.deleteConfigDoc("transferinfo", wflowName)
except Exception as exc:
self.logger.warning(
"Failed to delete transfer doc: %s. Error: %s", wflowName,
str(exc))
self.logger.info("Transfer documents cleanup completed.")
def acdcCleanup(self, config):
"""
gather active data statistics
"""
self.logger.info("Fetching ACDC collection names...")
originalRequests = self.acdcService.listCollectionNames()
if not originalRequests:
self.logger.info(" there are no collection documents to delete.")
return
# filter requests
results = self.reqDB._getCouchView("byrequest", {}, originalRequests)
# filter requests only in the following status
deleteStates = [
"announced", "rejected-archived", "aborted-archived",
"normal-archived"
]
filteredRequests = []
for row in results["rows"]:
if row["value"][0] in deleteStates:
filteredRequests.append(row["key"])
total = 0
for req in filteredRequests:
try:
self.logger.info("Removing ACDC collection for: %s", req)
deleted = self.acdcService.removeFilesetsByCollectionName(req)
if deleted is None:
self.logger.warning(" request '%s' already deleted", req)
else:
total += len(deleted)
self.logger.info("request %s deleted", req)
except Exception as ex:
self.logger.error(
"Failed to delete request: %s, will try again later. Error: %s",
req, str(ex))
self.logger.info("total %s requests deleted", total)
return
def __init__(self, rest, config):
super(AuxCacheUpdateTasks, self).__init__(config)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url)
class RequestInfo(object):
def __init__(self, microConfig, uniConfig, logger=None):
"""
Runs the basic setup and initialization for the MS Transferor module
:param microConfig: microservice configuration
"""
self.msConfig = microConfig
self.uConfig = uniConfig
self.reqRecords = []
self.logger = getMSLogger(microConfig['verbose'], logger=logger)
self.reqmgr2 = ReqMgr(microConfig['reqmgrUrl'], logger=self.logger)
self.reqmgrAux = ReqMgrAux(microConfig['reqmgrUrl'], httpDict={'cacheduration': 60}, logger=self.logger)
# eventually will change it to Rucio
self.phedex = PhEDEx(httpDict={'cacheduration': 10 * 60},
dbsUrl=microConfig['dbsUrl'], logger=self.logger)
def __call__(self, reqRecords):
"""
Run the unified transferor box
:param args:
:param kwargs:
:return:
"""
self.reqRecords = reqRecords
self.logger.info("Going to process %d requests.", len(self.reqRecords))
# get complete requests information (based on Unified Transferor logic)
self.requestsInfo()
requestsToProcess = self.unified()
return requestsToProcess
def requestsInfo(self):
"""
Helper function to get information about all requests
"""
# get campaigns for all requests which will be used to decide
# how many replicas have to be made and where data has to be subscribed to
# FIXME: it looks like we don't fetch all the possible campaigns in a given request
for req in self.reqRecords:
reqName = req['name']
for wflow in getWorkflow(reqName, self.msConfig['reqmgrUrl']):
campaign = wflow[reqName]['Campaign']
self.logger.debug("request: %s, campaign: %s", reqName, campaign)
campaignConfig = self.reqmgrAux.getCampaignConfig(campaign)
self.logger.debug("request: %s, campaignConfig: %s", reqName, campaignConfig)
if not campaignConfig:
# we skip and create alert
msg = 'No campagin configuration found for %s' % reqName
msg += ', skip transferor step ...'
self.logger.warning(msg)
continue
self.reqRecords['campaign'].append(campaignConfig)
def unified(self):
"""
Unified Transferor black box
"""
# get aux info for dataset/blocks from inputs/parents/pileups
# make subscriptions based on site white/black lists
self.logger.info("unified processing %d requests", len(self.reqRecords))
requests = [r['name'] for r in self.reqRecords]
### TODO: the logic below shows original unified port and it should be
### revisited wrt new proposal specs and unified codebase
# get workflows from list of requests
orig = time.time()
time0 = time.time()
requestWorkflows = self._getRequestWorkflows(requests)
workflows = requestWorkflows.values()
self.logger.debug(elapsedTime(time0, "### getWorkflows"))
# get workflows info summaries and collect datasets we need to process
winfo = workflowsInfo(workflows)
datasets = [d for row in winfo.values() for d in row['datasets']]
# find dataset info
time0 = time.time()
datasetBlocks, datasetSizes = dbsInfo(datasets, self.msConfig['dbsUrl'])
self.logger.debug(elapsedTime(time0, "### dbsInfo"))
# find block nodes information for our datasets
time0 = time.time()
blockNodes = phedexInfo(datasets, self.msConfig['phedexUrl'])
self.logger.debug(elapsedTime(time0, "### phedexInfo"))
# find events-lumis info for our datasets
time0 = time.time()
eventsLumis = eventsLumisInfo(datasets, self.msConfig['dbsUrl'])
self.logger.debug(elapsedTime(time0, "### eventsLumisInfo"))
# get specs for all requests and re-use them later in getSiteWhiteList as cache
requests = [v['RequestName'] for w in workflows for v in w.values()]
reqSpecs = self._getRequestSpecs(requests)
# get siteInfo instance once and re-use it later, it is time-consumed object
siteInfo = SiteInfo(self.uConfig)
requestsToProcess = []
tst0 = time.time()
totBlocks = totEvents = totSize = totCpuT = 0
for wflow in workflows:
for wname, wspec in wflow.items():
time0 = time.time()
cput = getComputingTime(wspec, eventsLumis=eventsLumis, dbsUrl=self.msConfig['dbsUrl'], logger=self.logger)
ncopies = getNCopies(cput)
attrs = winfo[wname]
ndatasets = len(attrs['datasets'])
npileups = len(attrs['pileups'])
nblocks = nevts = nlumis = size = 0
nodes = set()
for dataset in attrs['datasets']:
blocks = datasetBlocks[dataset]
for blk in blocks:
for node in blockNodes.get(blk, []):
nodes.add(node)
nblocks += len(blocks)
size += datasetSizes[dataset]
edata = eventsLumis.get(dataset, {'num_event': 0, 'num_lumi': 0})
nevts += edata['num_event']
nlumis += edata['num_lumi']
totBlocks += nblocks
totEvents += nevts
totSize += size
totCpuT += cput
sites = json.dumps(sorted(list(nodes)))
self.logger.debug("### %s", wname)
self.logger.debug(
"%s datasets, %s blocks, %s bytes (%s TB), %s nevts, %s nlumis, cput %s, copies %s, %s",
ndatasets, nblocks, size, teraBytes(size), nevts, nlumis, cput, ncopies, sites)
# find out which site can serve given workflow request
t0 = time.time()
lheInput, primary, parent, secondary, allowedSites \
= self._getSiteWhiteList(wspec, siteInfo, reqSpecs)
if not isinstance(primary, list):
primary = [primary]
if not isinstance(secondary, list):
secondary = [secondary]
wflowDatasets = primary + secondary
wflowDatasetsBlocks = []
for dset in wflowDatasets:
for item in datasetBlocks.get(dset, []):
wflowDatasetsBlocks.append(item)
rdict = dict(name=wname, datasets=wflowDatasets,
blocks=wflowDatasetsBlocks,
npileups=npileups, size=size,
nevents=nevts, nlumis=nlumis, cput=cput, ncopies=ncopies,
sites=sites, allowedSites=allowedSites, parent=parent,
lheInput=lheInput, primary=primary, secondary=secondary)
requestsToProcess.append(rdict)
self.logger.debug(elapsedTime(t0, "### getSiteWhiteList"))
self.logger.debug("total # of workflows %s, datasets %s, blocks %s, evts %s, size %s (%s TB), cput %s (hours)",
len(winfo.keys()), len(datasets), totBlocks, totEvents, totSize, teraBytes(totSize), totCpuT)
self.logger.debug(elapsedTime(tst0, '### workflows info'))
self.logger.debug(elapsedTime(orig, '### total time'))
return requestsToProcess
def _getRequestWorkflows(self, requestNames):
"Helper function to get all specs for given set of request names"
urls = [str('%s/data/request/%s' % (self.msConfig['reqmgrUrl'], r)) for r in requestNames]
self.logger.debug("getRequestWorkflows")
for u in urls:
self.logger.debug("url %s", u)
data = multi_getdata(urls, ckey(), cert())
rdict = {}
for row in data:
req = row['url'].split('/')[-1]
try:
data = json.loads(row['data'])
rdict[req] = data['result'][0] # we get back {'result': [workflow]} dict
except Exception as exp:
self.logger.error("fail to process row %s", row)
self.logger.exception("fail to load data as json record, error=%s", str(exp))
return rdict
def _getRequestSpecs(self, requestNames):
"Helper function to get all specs for given set of request names"
urls = [str('%s/%s/spec' % (self.msConfig['reqmgrCacheUrl'], r)) for r in requestNames]
data = multi_getdata(urls, ckey(), cert())
rdict = {}
for row in data:
req = row['url'].split('/')[-2]
rdict[req] = pickle.loads(row['data'])
return rdict
def _getSiteWhiteList(self, request, siteInfo, reqSpecs=None, pickone=False):
"Return site list for given request"
lheinput, primary, parent, secondary = getIO(request, self.msConfig['dbsUrl'])
allowedSites = []
if lheinput:
allowedSites = sorted(siteInfo.sites_eos)
elif secondary:
if self.heavyRead(request):
allowedSites = sorted(set(siteInfo.sites_T1s + siteInfo.sites_with_goodIO))
else:
allowedSites = sorted(set(siteInfo.sites_T1s + siteInfo.sites_with_goodAAA))
elif primary:
allowedSites = sorted(set(siteInfo.sites_T1s + siteInfo.sites_T2s + siteInfo.sites_T3s))
else:
# no input at all all site should contribute
allowedSites = sorted(set(siteInfo.sites_T2s + siteInfo.sites_T1s + siteInfo.sites_T3s))
if pickone:
allowedSites = sorted([siteInfo.pick_CE(allowedSites)])
# do further restrictions based on memory
# do further restrictions based on blow-up factor
minChildJobPerEvent, rootJobPerEvent, blowUp = self._getBlowupFactors(request, reqSpecs=reqSpecs)
maxBlowUp, neededCores = self.uConfig.get('blow_up_limits', (0, 0))
if blowUp > maxBlowUp:
# then restrict to only sites with >4k slots
newAllowedSites = list(set(allowedSites) &
set([site for site in allowedSites
if siteInfo.cpu_pledges[site] > neededCores]))
if newAllowedSites:
allowedSites = newAllowedSites
msg = "restricting site white list because of blow-up factor: "
msg += 'minChildJobPerEvent=%s ' % minChildJobPerEvent
msg += 'rootJobPerEvent=%s' % rootJobPerEvent
msg += 'maxBlowUp=%s' % maxBlowUp
self.logger.debug(msg)
for campaign in self.getCampaigns(request):
# for testing purposes add post campaign call
# res = reqmgrAux.postCampaignConfig(campaign, {'%s_name' % campaign: {"Key1": "Value1"}})
campaignConfig = self.reqmgrAux.getCampaignConfig(campaign)
if isinstance(campaignConfig, list):
campaignConfig = campaignConfig[0]
campSites = campaignConfig.get('SiteWhitelist', [])
if campSites:
msg = "Using site whitelist restriction by campaign=%s " % campaign
msg += "configuration=%s" % sorted(campSites)
self.logger.debug(msg)
allowedSites = list(set(allowedSites) & set(campSites))
if not allowedSites:
allowedSites = list(campSites)
campBlackList = campaignConfig.get('SiteBlacklist', [])
if campBlackList:
self.logger.debug("Reducing the whitelist due to black list in campaign configuration")
self.logger.debug("Removing %s", campBlackList)
allowedSites = list(set(allowedSites) - set(campBlackList))
ncores = self.getMulticore(request)
memAllowed = siteInfo.sitesByMemory(float(request['Memory']), maxCore=ncores)
if memAllowed is not None:
msg = "sites allowing %s " % request['Memory']
msg += "MB and ncores=%s" % ncores
msg += "core are %s" % sorted(memAllowed)
self.logger.debug(msg)
# mask to sites ready for mcore
if ncores > 1:
memAllowed = list(set(memAllowed) & set(siteInfo.sites_mcore_ready))
allowedSites = list(set(allowedSites) & set(memAllowed))
return lheinput, list(primary), list(parent), list(secondary), list(sorted(allowedSites))
def _getBlowupFactors(self, request, reqSpecs=None):
"Return blowup factors for given request"
if request['RequestType'] != 'TaskChain':
return 1., 1., 1.
minChildJobPerEvent = None
rootJobPerEvent = None
maxBlowUp = 0
splits = self._getSplittings(request, reqSpecs=reqSpecs)
for item in splits:
cSize = None
pSize = None
task = item['splittingTask']
for key in ['events_per_job', 'avg_events_per_job']:
if key in item:
cSize = item[key]
parents = [s for s in splits \
if task.startswith(s['splittingTask']) and task != s['splittingTask']]
if parents:
for parent in parents:
for key in ['events_per_job', 'avg_events_per_job']:
if key in parent:
pSize = parent[key]
if not minChildJobPerEvent or minChildJobPerEvent > cSize:
minChildJobPerEvent = cSize
else:
rootJobPerEvent = cSize
if cSize and pSize:
blowUp = float(pSize) / cSize
if blowUp > maxBlowUp:
maxBlowUp = blowUp
return minChildJobPerEvent, rootJobPerEvent, maxBlowUp
def _getSplittings(self, request, reqSpecs=None):
"Return splittings for given request"
spl = []
for task in self.getWorkTasks(request, reqSpecs=reqSpecs):
tsplit = task.input.splitting
spl.append({"splittingAlgo": tsplit.algorithm, "splittingTask": task.pathName})
get_those = ['events_per_lumi', 'events_per_job', 'lumis_per_job',
'halt_job_on_file_boundaries', 'job_time_limit',
'halt_job_on_file_boundaries_event_aware']
translate = {'EventAwareLumiBased': [('events_per_job', 'avg_events_per_job')]}
include = {'EventAwareLumiBased': {'halt_job_on_file_boundaries_event_aware': 'True'},
'LumiBased': {'halt_job_on_file_boundaries': 'True'}}
if tsplit.algorithm in include:
for key, val in include[tsplit.algorithm].items():
spl[-1][key] = val
for get in get_those:
if hasattr(tsplit, get):
setTo = get
if tsplit.algorithm in translate:
for src, des in translate[tsplit.algorithm]:
if src == get:
setTo = des
break
spl[-1][setTo] = getattr(tsplit, get)
return spl
def getWorkTasks(self, request, reqSpecs=None):
"Return work tasks for given request"
select = {'taskType': ['Production', 'Processing', 'Skim']}
allTasks = []
tasks = self.getSpec(request, reqSpecs).tasks
for task in tasks.tasklist:
node = getattr(tasks, task)
allTasks.extend(self.taskDescending(node, select))
return allTasks
def getSpec(self, request, reqSpecs=None):
"Get request from workload cache"
if reqSpecs and request['RequestName'] in reqSpecs:
return reqSpecs[request['RequestName']]
url = str('%s/%s/spec' % (self.msConfig['reqmgrCacheUrl'], request['RequestName']))
mgr = RequestHandler()
data = mgr.getdata(url, params={}, cert=cert(), ckey=ckey())
return pickle.loads(data)
def taskDescending(self, node, select=None):
"Helper function to walk through task nodes in descending order"
allTasks = []
if not select:
allTasks.append(node)
else:
for key, value in select.items():
if (isinstance(value, list) and getattr(node, key) in value) or \
(not isinstance(value, list) and getattr(node, key) == value):
allTasks.append(node)
break
for child in node.tree.childNames:
chItem = getattr(node.tree.children, child)
allTasks.extend(self.taskDescending(chItem, select))
return allTasks
def getCampaigns(self, request):
"Return campaigns of given request"
if 'Chain' in request['RequestType'] and not self.isRelval(request):
return list(set(self.collectinchain(request, 'AcquisitionEra').values()))
return [request['Campaign']]
def heavyRead(self, request):
"""
Return True by default. False if 'premix' appears in the
output datasets or in the campaigns
"""
response = True
if any(['premix' in c.lower() for c in self.getCampaigns(request)]):
response = False
if any(['premix' in o.lower() for o in request['OutputDatasets']]):
response = False
return response
def isRelval(self, request):
"Return if given request is RelVal sample"
if 'SubRequestType' in request and 'RelVal' in request['SubRequestType']:
return True
return False
def collectinchain(self, request, member, func=None, default=None):
"Helper function to return dictionary of collection chain"
if request['RequestType'] == 'StepChain':
return self.collectionHelper(request, member, func, default, base='Step')
elif request['RequestType'] == 'TaskChain':
return self.collectionHelper(request, member, func, default, base='Task')
else:
raise Exception("should not call collectinchain on non-chain request")
def collectionHelper(self, request, member, func=None, default=None, base=None):
"Helper function to return uhm chain as a dictionary"
coll = {}
item = 1
while '%s%d' % (base, item) in request:
if member in request['%s%d' % (base, item)]:
if func:
coll[request['%s%d' % (base, item)]['%sName' % base]] = \
func(request['%s%d' % (base, item)][member])
else:
coll[request['%s%d' % (base, item)]['%sName' % base]] = \
request['%s%d' % (base, item)].get(member, default)
item += 1
return coll
def getMulticore(self, request):
"Return max number of cores for a given request"
mcores = [int(request.get('Multicore', 1))]
if 'Chain' in request['RequestType']:
mcoresCol = self.collectinchain(request, 'Multicore', default=1)
mcores.extend([int(v) for v in mcoresCol.values()])
return max(mcores)
class ErrorHandlerPoller(BaseWorkerThread):
"""
Polls for Error Conditions, handles them
"""
def __init__(self, config):
"""
Initialise class members
"""
BaseWorkerThread.__init__(self)
self.config = config
myThread = threading.currentThread()
self.daoFactory = DAOFactory(package="WMCore.WMBS",
logger=myThread.logger,
dbinterface=myThread.dbi)
self.changeState = ChangeState(self.config)
if hasattr(self.config, "Tier0Feeder"):
self.reqAuxDB = None
self.maxRetries = self.config.ErrorHandler.maxRetries
else:
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
self.maxRetries = self.reqAuxDB.getWMAgentConfig(self.config.Agent.hostName).get("MaxRetries")
if not isinstance(self.maxRetries, dict):
self.maxRetries = {'default': self.maxRetries}
if 'default' not in self.maxRetries:
raise ErrorHandlerException('Max retries for the default job type must be specified')
self.exitCodesNoRetry = []
self.maxProcessSize = getattr(self.config.ErrorHandler, 'maxProcessSize', 250)
self.maxFailTime = getattr(self.config.ErrorHandler, 'maxFailTime', 32 * 3600)
self.readFWJR = getattr(self.config.ErrorHandler, 'readFWJR', False)
self.passCodes = getattr(self.config.ErrorHandler, 'passExitCodes', [])
self.getJobs = self.daoFactory(classname="Jobs.GetAllJobs")
self.idLoad = self.daoFactory(classname="Jobs.LoadFromIDWithType")
self.loadAction = self.daoFactory(classname="Jobs.LoadForErrorHandler")
self.dataCollection = DataCollectionService(url=config.ACDC.couchurl,
database=config.ACDC.database)
return
def setup(self, parameters=None):
"""
Load DB objects required for queries
"""
# For now, does nothing
return
def terminate(self, params):
"""
_terminate_
Do one pass, then commit suicide
"""
logging.debug("terminating. doing one more pass before we die")
self.algorithm(params)
def exhaustJobs(self, jobList):
"""
_exhaustJobs_
Actually do the jobs exhaustion
"""
# Remove all the files in the exhausted jobs.
logging.debug("About to fail input files for exhausted jobs")
for job in jobList:
job.failInputFiles()
# Do not build ACDC for utilitarian job types
acdcJobList = [job for job in jobList if job['type'] not in ['LogCollect', 'Cleanup']]
self.handleACDC(acdcJobList)
self.changeState.propagate(jobList, 'exhausted', 'retrydone')
return
def processRetries(self, jobList, state):
"""
_processRetries_
Actually do the retries
"""
logging.info("Processing retries for %d failed jobs of type %sfailed", len(jobList), state)
retrydoneJobs = []
cooloffJobs = []
passJobs = []
# Query auxiliary db for current state of maxRetries
if self.reqAuxDB:
self.maxRetries = self.reqAuxDB.getWMAgentConfig(self.config.Agent.hostName).get("MaxRetries", self.maxRetries)
if not isinstance(self.maxRetries, dict):
self.maxRetries = {'default': self.maxRetries}
if 'default' not in self.maxRetries:
raise ErrorHandlerException('Max retries for the default job type must be specified')
# Retries < max retry count
for job in jobList:
allowedRetries = self.maxRetries.get(job['type'], self.maxRetries['default'])
# Retries < allowed max retry count
if job['retry_count'] < allowedRetries and state != 'create':
cooloffJobs.append(job)
# Check if Retries >= allowed max retry count
elif job['retry_count'] >= allowedRetries or state == 'create':
retrydoneJobs.append(job)
msg = "Stopping retries for job %d" % job['id']
logging.debug(msg)
logging.debug("JobInfo: %s", job)
if self.readFWJR:
# Then we have to check each FWJR for exit status
cooloffJobs, passJobs, retrydoneFWJRJobs = self.readFWJRForErrors(cooloffJobs)
retrydoneJobs.extend(retrydoneFWJRJobs)
# Now to actually do something.
logging.debug("About to propagate jobs")
if len(retrydoneJobs) > 0:
self.changeState.propagate(retrydoneJobs, 'retrydone',
'%sfailed' % state, updatesummary=True)
if len(cooloffJobs) > 0:
self.changeState.propagate(cooloffJobs, '%scooloff' % state,
'%sfailed' % state, updatesummary=True)
if len(passJobs) > 0:
# Overwrite the transition states and move directly to created
self.changeState.propagate(passJobs, 'created', 'new')
return
def handleACDC(self, jobList):
"""
_handleACDC_
Do the ACDC creation and hope it works
"""
idList = [x['id'] for x in jobList]
logging.info("Starting to build ACDC with %i jobs", len(idList))
logging.info("This operation will take some time...")
loadList = self.loadJobsFromListFull(idList)
for job in loadList:
job.getMask()
self.dataCollection.failedJobs(loadList)
return
def readFWJRForErrors(self, jobList):
"""
_readFWJRForErrors_
Check the FWJRs of the failed jobs
and determine those that can be retried
and which must be retried without going through cooloff.
Returns a triplet with cooloff, passed and exhausted jobs.
"""
cooloffJobs = []
passJobs = []
exhaustJobs = []
if self.reqAuxDB:
self.exitCodesNoRetry = self.reqAuxDB.getWMAgentConfig(self.config.Agent.hostName).get("NoRetryExitCodes", [])
for job in jobList:
report = Report()
reportPath = job['fwjr_path']
if reportPath is None:
logging.error("No FWJR in job %i, ErrorHandler can't process it.\n Passing it to cooloff.", job['id'])
cooloffJobs.append(job)
continue
if not os.path.isfile(reportPath):
logging.error(
"Failed to find FWJR for job %i in location %s.\n Passing it to cooloff.", job['id'], reportPath)
cooloffJobs.append(job)
continue
try:
report.load(reportPath)
# First let's check the time conditions
times = report.getFirstStartLastStop()
startTime = None
stopTime = None
if times is not None:
startTime = times['startTime']
stopTime = times['stopTime']
# correct the location if the original location is different from recorded in wmbs
# WARNING: we are not updating job location in wmbs only updating in couchdb by doing this.
# If location in wmbs needs to be updated, it should happen in JobAccountant.
locationFromFWJR = report.getSiteName()
if locationFromFWJR:
job["location"] = locationFromFWJR
job["site_cms_name"] = locationFromFWJR
if startTime is None or stopTime is None:
# We have no information to make a decision, keep going.
logging.debug("No start, stop times for steps for job %i", job['id'])
elif stopTime - startTime > self.maxFailTime:
msg = "Job %i exhausted after running on node for %i seconds" % (job['id'], stopTime - startTime)
logging.debug(msg)
exhaustJobs.append(job)
continue
if len([x for x in report.getExitCodes() if x in self.exitCodesNoRetry]):
msg = "Job %i exhausted due to a bad exit code (%s)" % (job['id'], str(report.getExitCodes()))
logging.debug(msg)
exhaustJobs.append(job)
continue
if len([x for x in report.getExitCodes() if x in self.passCodes]):
msg = "Job %i restarted immediately due to an exit code (%s)" % (job['id'],
str(report.getExitCodes()))
logging.debug(msg)
passJobs.append(job)
continue
cooloffJobs.append(job)
except Exception as ex:
logging.warning("Exception while trying to check jobs for failures!")
logging.warning(str(ex))
logging.warning("Ignoring and sending job to cooloff")
cooloffJobs.append(job)
return cooloffJobs, passJobs, exhaustJobs
def handleRetryDoneJobs(self, jobList):
"""
_handleRetryDoneJobs_
"""
myThread = threading.currentThread()
logging.info("About to process %d retry done jobs", len(jobList))
myThread.transaction.begin()
self.exhaustJobs(jobList)
myThread.transaction.commit()
return
def handleFailedJobs(self, jobList, state):
"""
_handleFailedJobs_
"""
myThread = threading.currentThread()
logging.info("About to process %d failures", len(jobList))
myThread.transaction.begin()
self.processRetries(jobList, state)
myThread.transaction.commit()
return
def handleErrors(self):
"""
Queries DB for all watched filesets, if matching filesets become
available, create the subscriptions
"""
# Run over created, submitted and executed job failures
failure_states = ['create', 'submit', 'job']
for state in failure_states:
idList = self.getJobs.execute(state="%sfailed" % state)
logging.info("Found %d failed jobs in state %sfailed", len(idList), state)
for jobSlice in grouper(idList, self.maxProcessSize):
jobList = self.loadJobsFromList(jobSlice)
self.handleFailedJobs(jobList, state)
# Run over jobs done with retries
idList = self.getJobs.execute(state='retrydone')
logging.info("Found %d jobs done with all retries", len(idList))
for jobSlice in grouper(idList, self.maxProcessSize):
jobList = self.loadJobsFromList(jobSlice)
self.handleRetryDoneJobs(jobList)
return
def loadJobsFromList(self, idList):
"""
_loadJobsFromList_
Load jobs in bulk
"""
binds = []
for jobID in idList:
binds.append({"jobid": jobID})
results = self.idLoad.execute(jobID=binds)
# You have to have a list
if isinstance(results, dict):
results = [results]
listOfJobs = []
for entry in results:
# One job per entry
tmpJob = Job(id=entry['id'])
tmpJob.update(entry)
listOfJobs.append(tmpJob)
return listOfJobs
def loadJobsFromListFull(self, idList):
"""
_loadJobsFromList_
Load jobs in bulk.
Include the full metadata.
"""
binds = []
for jobID in idList:
binds.append({"jobid": jobID})
results = self.loadAction.execute(jobID=binds)
# You have to have a list
if isinstance(results, dict):
results = [results]
listOfJobs = []
for entry in results:
# One job per entry
tmpJob = Job(id=entry['id'])
tmpJob.update(entry)
listOfJobs.append(tmpJob)
return listOfJobs
@timeFunction
def algorithm(self, parameters=None):
"""
Performs the handleErrors method, looking for each type of failure
And deal with it as desired.
"""
logging.debug("Running error handling algorithm")
try:
myThread = threading.currentThread()
self.handleErrors()
except (CouchConnectionError, HTTPException) as ex:
if getattr(myThread, 'transaction', None) is not None:
myThread.transaction.rollback()
msg = "Caught CouchConnectionError/HTTPException exception in ErrorHandler. "
msg += "Transactions postponed until the next polling cycle\n"
msg += str(ex)
logging.error(msg)
except Exception as ex:
if getattr(myThread, 'transaction', None) is not None:
myThread.transaction.rollback()
msg = "Caught unexpected exception in ErrorHandler:\n"
msg += str(ex)
logging.exception(msg)
raise ErrorHandlerException(msg)
def __init__(self, rest, config):
super(AuxCacheUpdateTasks, self).__init__(config)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url, logger=self.logger)
self.mgr = RequestHandler()
class MSManager(object):
"""
Entry point for the MicroServices.
This class manages both transferor and monitor services/threads.
"""
def __init__(self, config=None, logger=None):
"""
Setup a bunch of things, like:
* logger for this service
* initialize all the necessary service helpers
* fetch the unified configuration from central couch
* update the unified configuration with some deployment and default settings
* start both transfer and monitor threads
:param config: reqmgr2ms service configuration
:param logger:
"""
self.uConfig = {}
self.config = config
self.logger = getMSLogger(getattr(config, 'verbose', False), logger)
self._parseConfig(config)
self.logger.info("Configuration including default values:\n%s",
self.msConfig)
self.reqmgr2 = ReqMgr(self.msConfig['reqmgrUrl'], logger=self.logger)
self.reqmgrAux = ReqMgrAux(self.msConfig['reqmgrUrl'],
httpDict={'cacheduration': 60},
logger=self.logger)
# transferor has to look at workflows in assigned status
self.msTransferor = MSTransferor(self.msConfig,
"assigned",
logger=self.logger)
### Last but not least, get the threads started
thname = 'MSTransferor'
self.transfThread = start_new_thread(
thname, daemon, (self.transferor, 'assigned',
self.msConfig['interval'], self.logger))
self.logger.debug("### Running %s thread %s", thname,
self.transfThread.running())
thname = 'MSTransferorMonit'
self.monitThread = start_new_thread(
thname, daemon, (self.monitor, 'staging',
self.msConfig['interval'] * 2, self.logger))
self.logger.debug("+++ Running %s thread %s", thname,
self.monitThread.running())
def _parseConfig(self, config):
"""
__parseConfig_
Parse the MicroService configuration and set any default values.
:param config: config as defined in the deployment
"""
self.logger.info("Using the following config:\n%s", config)
self.msConfig = {}
self.msConfig['verbose'] = getattr(config, 'verbose', False)
self.msConfig['group'] = getattr(config, 'group', 'DataOps')
self.msConfig['interval'] = getattr(config, 'interval', 5 * 60)
self.msConfig['readOnly'] = getattr(config, 'readOnly', True)
self.msConfig['reqmgrUrl'] = getattr(config, 'reqmgr2Url',
'https://cmsweb.cern.ch/reqmgr2')
self.msConfig['reqmgrCacheUrl'] = self.msConfig['reqmgrUrl'].replace(
'reqmgr2', 'couchdb/reqmgr_workload_cache')
self.msConfig['phedexUrl'] = getattr(
config, 'phedexUrl',
'https://cmsweb.cern.ch/phedex/datasvc/json/prod')
self.msConfig['dbsUrl'] = getattr(
config, 'dbsUrl',
'https://cmsweb.cern.ch/dbs/prod/global/DBSReader')
def transferor(self, reqStatus):
"""
MSManager transferor function.
It performs Unified logic for data subscription and
transfers requests from assigned to staging/staged state of ReqMgr2.
For references see
https://github.com/dmwm/WMCore/wiki/ReqMgr2-MicroService-Transferor
"""
startT = time.time()
self.logger.info("Starting the transferor thread...")
self.msTransferor.execute()
self.logger.info("Total transferor execution time: %.2f secs",
time.time() - startT)
def monitor(self, reqStatus='staging'):
"""
MSManager monitoring function.
It performs transfer requests from staging to staged state of ReqMgr2.
For references see
https://github.com/dmwm/WMCore/wiki/ReqMgr2-MicroService-Transferor
"""
startT = time.time()
self.logger.info("Starting the monitor thread...")
# First, fetch/update our unified configuration from reqmgr_aux db
# Keep our own copy of the unified config to avoid race conditions
self.uConfig = self.reqmgrAux.getUnifiedConfig(docName="config")
if not self.uConfig:
self.logger.warning(
"Monitor failed to fetch the unified config. Skipping this cycle."
)
return
self.uConfig = self.uConfig[0]
try:
# get requests from ReqMgr2 data-service for given statue
# here with detail=False we get back list of records
requests = self.reqmgr2.getRequestByStatus([reqStatus],
detail=False)
self.logger.debug('+++ monit found %s requests in %s state',
len(requests), reqStatus)
requestStatus = {} # keep track of request statuses
for reqName in requests:
req = {'name': reqName, 'reqStatus': reqStatus}
# get transfer IDs
tids = self.getTransferIDs()
# get transfer status
transferStatuses = self.getTransferStatuses(tids)
# get campaing and unified configuration
campaign = self.requestCampaign(reqName)
conf = self.requestConfiguration(reqName)
self.logger.debug("+++ request %s campaing %s conf %s", req,
campaign, conf)
# if all transfers are completed, move the request status staging -> staged
# completed = self.checkSubscription(request)
completed = 100 # TMP
if completed == 100: # all data are staged
self.logger.debug(
"+++ request %s all transfers are completed", req)
self.change(req, 'staged', '+++ monit')
# if pileup transfers are completed AND some input blocks are completed, move the request status staging -> staged
elif self.pileupTransfersCompleted(tids):
self.logger.debug(
"+++ request %s pileup transfers are completed", req)
self.change(req, 'staged', '+++ monit')
# transfers not completed, just update the database with their completion
else:
self.logger.debug(
"+++ request %s transfers are not completed", req)
requestStatus[
req] = transferStatuses # TODO: implement update of transfer ids
self.updateTransferIDs(requestStatus)
except Exception as err: # general error
self.logger.exception('+++ monit error: %s', str(err))
self.logger.info("Total monitor execution time: %.2f secs",
time.time() - startT)
def stop(self):
"Stop MSManager"
# stop MSTransferorMonit thread
self.monitThread.stop()
# stop MSTransferor thread
self.transfThread.stop() # stop checkStatus thread
status = self.transfThread.running()
return status
def getTransferIDsDoc(self):
"""
Get transfer ids document from backend. The document has the following form:
{
"wf_A": [record1, record2, ...],
"wf_B": [....],
}
where each record has the following format:
{"timestamp":000, "dataset":"/a/b/c", "type": "primary", "trainsferIDs": [1,2,3]}
"""
doc = {}
return doc
def updateTransferIDs(self, requestStatus):
"Update transfer ids in backend"
# TODO/Wait: https://github.com/dmwm/WMCore/issues/9198
# doc = self.getTransferIDsDoc()
def getTransferIDs(self):
"Get transfer ids from backend"
# TODO/Wait: https://github.com/dmwm/WMCore/issues/9198
# meanwhile return transfer ids from internal store
return []
def getTransferStatuses(self, tids):
"get transfer statuses for given transfer IDs from backend"
# transfer docs on backend has the following form
# https://gist.github.com/amaltaro/72599f995b37a6e33566f3c749143154
statuses = {}
for tid in tids:
# TODO: I need to find request name from transfer ID
# status = self.checkSubscription(request)
status = 100
statuses[tid] = status
return statuses
def requestCampaign(self, req):
"Return request campaign"
return 'campaign_TODO' # TODO
def requestConfiguration(self, req):
"Return request configuration"
return {}
def pileupTransfersCompleted(self, tids):
"Check if pileup transfers are completed"
# TODO: add implementation
return False
def checkSubscription(self, req):
"Send request to Phedex and return status of request subscription"
sdict = {}
for dataset in req.get('datasets', []):
data = self.phedex.subscriptions(dataset=dataset,
group=self.msConfig['group'])
self.logger.debug("### dataset %s group %s", dataset,
self.msConfig['group'])
self.logger.debug("### subscription %s", data)
for row in data['phedex']['dataset']:
if row['name'] != dataset:
continue
nodes = [s['node'] for s in row['subscription']]
rNodes = req.get('sites')
self.logger.debug("### nodes %s %s", nodes, rNodes)
subset = set(nodes) & set(rNodes)
if subset == set(rNodes):
sdict[dataset] = 1
else:
pct = float(len(subset)) / float(len(set(rNodes)))
sdict[dataset] = pct
self.logger.debug("### sdict %s", sdict)
tot = len(sdict.keys())
if not tot:
return -1
# return percentage of completion
return round(float(sum(sdict.values())) / float(tot), 2) * 100
def checkStatus(self, req):
"Check status of request in local storage"
self.logger.debug("### checkStatus of request: %s", req['name'])
# check subscription status of the request
# completed = self.checkSubscription(req)
completed = 100
if completed == 100: # all data are staged
self.logger.debug(
"### request is completed, change its status and remove it from the store"
)
self.change(req, 'staged', '### transferor')
else:
self.logger.debug("### request %s, completed %s", req, completed)
def info(self, req):
"Return info about given request"
completed = self.checkSubscription(req)
return {'request': req, 'status': completed}
def delete(self, request):
"Delete request in backend"
pass
def change(self, req, reqStatus, prefix='###'):
"""
Change request status, internally it is done via PUT request to ReqMgr2:
curl -X PUT -H "Content-Type: application/json" \
-d '{"RequestStatus":"staging", "RequestName":"bla-bla"}' \
https://xxx.yyy.zz/reqmgr2/data/request
"""
self.logger.debug('%s updating %s status to %s', prefix, req['name'],
reqStatus)
try:
if not self.msConfig['readOnly']:
self.reqmgr2.updateRequestStatus(req['name'], reqStatus)
except Exception as err:
self.logger.exception("Failed to change request status. Error: %s",
str(err))
class JobSubmitterPoller(BaseWorkerThread):
"""
_JobSubmitterPoller_
The jobSubmitterPoller takes the jobs and organizes them into packages
before sending them to the individual plugin submitters.
"""
def __init__(self, config):
BaseWorkerThread.__init__(self)
myThread = threading.currentThread()
self.config = config
#DAO factory for WMBS objects
self.daoFactory = DAOFactory(package="WMCore.WMBS", logger=logging, dbinterface=myThread.dbi)
#Libraries
self.resourceControl = ResourceControl()
self.changeState = ChangeState(self.config)
self.bossAir = BossAirAPI(config=self.config)
self.hostName = self.config.Agent.hostName
self.repollCount = getattr(self.config.JobSubmitter, 'repollCount', 10000)
self.maxJobsPerPoll = int(getattr(self.config.JobSubmitter, 'maxJobsPerPoll', 1000))
self.maxJobsThisCycle = self.maxJobsPerPoll # changes as per schedd limit
self.cacheRefreshSize = int(getattr(self.config.JobSubmitter, 'cacheRefreshSize', 30000))
self.skipRefreshCount = int(getattr(self.config.JobSubmitter, 'skipRefreshCount', 20))
self.packageSize = getattr(self.config.JobSubmitter, 'packageSize', 500)
self.collSize = getattr(self.config.JobSubmitter, 'collectionSize', self.packageSize * 1000)
self.maxTaskPriority = getattr(self.config.BossAir, 'maxTaskPriority', 1e7)
self.condorFraction = 0.75 # update during every algorithm cycle
self.condorOverflowFraction = 0.2
self.ioboundTypes = ('LogCollect', 'Merge', 'Cleanup', 'Harvesting')
# Additions for caching-based JobSubmitter
self.cachedJobIDs = set()
self.cachedJobs = {}
self.jobDataCache = {}
self.jobsToPackage = {}
self.sandboxPackage = {}
self.locationDict = {}
self.taskTypePrioMap = {}
self.drainSites = set()
self.abortSites = set()
self.refreshPollingCount = 0
try:
if not getattr(self.config.JobSubmitter, 'submitDir', None):
self.config.JobSubmitter.submitDir = self.config.JobSubmitter.componentDir
self.packageDir = os.path.join(self.config.JobSubmitter.submitDir, 'packages')
if not os.path.exists(self.packageDir):
os.makedirs(self.packageDir)
except OSError as ex:
msg = "Error while trying to create packageDir %s\n!"
msg += str(ex)
logging.error(msg)
logging.debug("PackageDir: %s", self.packageDir)
logging.debug("Config: %s", config)
raise JobSubmitterPollerException(msg)
# Now the DAOs
self.listJobsAction = self.daoFactory(classname="Jobs.ListForSubmitter")
self.setLocationAction = self.daoFactory(classname="Jobs.SetLocation")
self.locationAction = self.daoFactory(classname="Locations.GetSiteInfo")
self.setFWJRPathAction = self.daoFactory(classname="Jobs.SetFWJRPath")
self.listWorkflows = self.daoFactory(classname="Workflow.ListForSubmitter")
# Keep a record of the thresholds in memory
self.currentRcThresholds = {}
self.useReqMgrForCompletionCheck = getattr(self.config.TaskArchiver, 'useReqMgrForCompletionCheck', True)
if self.useReqMgrForCompletionCheck:
# only set up this when reqmgr is used (not Tier0)
self.reqmgr2Svc = ReqMgr(self.config.General.ReqMgr2ServiceURL)
self.abortedAndForceCompleteWorkflowCache = self.reqmgr2Svc.getAbortedAndForceCompleteRequestsFromMemoryCache()
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
else:
# Tier0 Case - just for the clarity (This private variable shouldn't be used
self.abortedAndForceCompleteWorkflowCache = None
return
def getPackageCollection(self, sandboxDir):
"""
_getPackageCollection_
Given a jobID figure out which packageCollection
it should belong in.
"""
rawList = os.listdir(sandboxDir)
collections = []
numberList = []
for entry in rawList:
if 'PackageCollection' in entry:
collections.append(entry)
# If we have no collections, return 0 (PackageCollection_0)
if len(collections) < 1:
return 0
# Loop over the list of PackageCollections
for collection in collections:
collectionPath = os.path.join(sandboxDir, collection)
packageList = os.listdir(collectionPath)
collectionNum = int(collection.split('_')[1])
if len(packageList) < self.collSize:
return collectionNum
else:
numberList.append(collectionNum)
# If we got here, then all collections are full. We'll need
# a new one. Find the highest number, increment by one
numberList.sort()
return numberList[-1] + 1
def addJobsToPackage(self, loadedJob):
"""
_addJobsToPackage_
Add a job to a job package and then return the batch ID for the job.
Packages are only written out to disk when they contain 100 jobs. The
flushJobsPackages() method must be called after all jobs have been added
to the cache and before they are actually submitted to make sure all the
job packages have been written to disk.
"""
if loadedJob["workflow"] not in self.jobsToPackage:
# First, let's pull all the information from the loadedJob
batchid = "%s-%s" % (loadedJob["id"], loadedJob["retry_count"])
sandboxDir = os.path.dirname(loadedJob["sandbox"])
# Second, assemble the jobPackage location
collectionIndex = self.getPackageCollection(sandboxDir)
collectionDir = os.path.join(sandboxDir,
'PackageCollection_%i' % collectionIndex,
'batch_%s' % batchid)
# Now create the package object
self.jobsToPackage[loadedJob["workflow"]] = {"batchid": batchid,
'id': loadedJob['id'],
"package": JobPackage(directory=collectionDir)}
jobPackage = self.jobsToPackage[loadedJob["workflow"]]["package"]
jobPackage[loadedJob["id"]] = loadedJob.getDataStructsJob()
batchDir = jobPackage['directory']
if len(jobPackage.keys()) == self.packageSize:
if not os.path.exists(batchDir):
os.makedirs(batchDir)
batchPath = os.path.join(batchDir, "JobPackage.pkl")
jobPackage.save(batchPath)
del self.jobsToPackage[loadedJob["workflow"]]
return batchDir
def flushJobPackages(self):
"""
_flushJobPackages_
Write any jobs packages to disk that haven't been written out already.
"""
workflowNames = self.jobsToPackage.keys()
for workflowName in workflowNames:
jobPackage = self.jobsToPackage[workflowName]["package"]
batchDir = jobPackage['directory']
if not os.path.exists(batchDir):
os.makedirs(batchDir)
batchPath = os.path.join(batchDir, "JobPackage.pkl")
jobPackage.save(batchPath)
del self.jobsToPackage[workflowName]
return
def refreshCache(self):
"""
_refreshCache_
Query WMBS for all jobs in the 'created' state. For all jobs returned
from the query, check if they already exist in the cache. If they
don't, unpickle them and combine their site white and black list with
the list of locations they can run at. Add them to the cache.
Each entry in the cache is a tuple with five items:
- WMBS Job ID
- Retry count
- Batch ID
- Path to sanbox
- Path to cache directory
"""
badJobs = dict([(x, []) for x in range(71101, 71105)])
dbJobs = set()
logging.info("Refreshing priority cache with currently %i jobs", len(self.cachedJobIDs))
if self.cacheRefreshSize == -1 or len(self.cachedJobIDs) < self.cacheRefreshSize or \
self.refreshPollingCount >= self.skipRefreshCount:
newJobs = self.listJobsAction.execute()
self.refreshPollingCount = 0
if self.useReqMgrForCompletionCheck:
# if reqmgr is used (not Tier0 Agent) get the aborted/forceCompleted record
abortedAndForceCompleteRequests = self.abortedAndForceCompleteWorkflowCache.getData()
else:
#T0Agent
abortedAndForceCompleteRequests = []
logging.info("Found %s new jobs to be submitted.", len(newJobs))
else:
self.refreshPollingCount += 1
newJobs = []
dbJobs = self.cachedJobIDs
abortedAndForceCompleteRequests = []
logging.info("Skipping cache update to be submitted. (%s job in cache)", len(dbJobs))
logging.info("Determining possible sites for new jobs...")
jobCount = 0
for newJob in newJobs:
# whether newJob belongs to aborted or force-complete workflow, and skip it if it is.
if (newJob['request_name'] in abortedAndForceCompleteRequests) and \
(newJob['type'] not in ['LogCollect', "Cleanup"]):
continue
jobID = newJob['id']
dbJobs.add(jobID)
if jobID in self.cachedJobIDs:
continue
jobCount += 1
if jobCount % 5000 == 0:
logging.info("Processed %d/%d new jobs.", jobCount, len(newJobs))
pickledJobPath = os.path.join(newJob["cache_dir"], "job.pkl")
if not os.path.isfile(pickledJobPath):
# Then we have a problem - there's no file
logging.error("Could not find pickled jobObject %s", pickledJobPath)
badJobs[71103].append(newJob)
continue
try:
jobHandle = open(pickledJobPath, "r")
loadedJob = pickle.load(jobHandle)
jobHandle.close()
except Exception as ex:
msg = "Error while loading pickled job object %s\n" % pickledJobPath
msg += str(ex)
logging.error(msg)
raise JobSubmitterPollerException(msg)
loadedJob['retry_count'] = newJob['retry_count']
# figure out possible locations for job
possibleLocations = loadedJob["possiblePSN"]
# Create another set of locations that may change when a site goes white/black listed
# Does not care about the non_draining or aborted sites, they may change and that is the point
potentialLocations = set()
potentialLocations.update(possibleLocations)
# now check for sites in drain and adjust the possible locations
# also check if there is at least one site left to run the job
if len(possibleLocations) == 0:
newJob['name'] = loadedJob['name']
newJob['fileLocations'] = loadedJob.get('fileLocations', [])
newJob['siteWhitelist'] = loadedJob.get('siteWhitelist', [])
newJob['siteBlacklist'] = loadedJob.get('siteBlacklist', [])
badJobs[71101].append(newJob)
continue
else:
nonAbortSites = [x for x in possibleLocations if x not in self.abortSites]
if nonAbortSites: # if there is at least a non aborted/down site then run there, otherwise fail the job
possibleLocations = nonAbortSites
else:
newJob['name'] = loadedJob['name']
newJob['possibleLocations'] = possibleLocations
badJobs[71102].append(newJob)
continue
# try to remove draining sites if possible, this is needed to stop
# jobs that could run anywhere blocking draining sites
# if the job type is Merge, LogCollect or Cleanup this is skipped
if newJob['type'] not in self.ioboundTypes:
nonDrainingSites = [x for x in possibleLocations if x not in self.drainSites]
if nonDrainingSites: # if >1 viable non-draining site remove draining ones
possibleLocations = nonDrainingSites
else:
newJob['name'] = loadedJob['name']
newJob['possibleLocations'] = possibleLocations
badJobs[71104].append(newJob)
continue
# locations clear of abort and draining sites
newJob['possibleLocations'] = possibleLocations
batchDir = self.addJobsToPackage(loadedJob)
self.cachedJobIDs.add(jobID)
# calculate the final job priority such that we can order cached jobs by prio
jobPrio = self.taskTypePrioMap.get(newJob['type'], 0) + newJob['wf_priority']
if jobPrio not in self.cachedJobs:
self.cachedJobs[jobPrio] = {}
# now add basic information keyed by the jobid
self.cachedJobs[jobPrio][jobID] = newJob
# allow job baggage to override numberOfCores
# => used for repacking to get more slots/disk
numberOfCores = loadedJob.get('numberOfCores', 1)
if numberOfCores == 1:
baggage = loadedJob.getBaggage()
numberOfCores = getattr(baggage, "numberOfCores", 1)
loadedJob['numberOfCores'] = numberOfCores
# Create a job dictionary object and put it in the cache (needs to be in sync with RunJob)
jobInfo = {'id': jobID,
'requestName': newJob['request_name'],
'taskName': newJob['task_name'],
'taskType': newJob['type'],
'cache_dir': newJob["cache_dir"],
'priority': newJob['wf_priority'],
'taskID': newJob['task_id'],
'retry_count': newJob["retry_count"],
'taskPriority': None, # update from the thresholds
'custom': {'location': None}, # update later
'packageDir': batchDir,
'sandbox': loadedJob["sandbox"], # remove before submit
'userdn': loadedJob.get("ownerDN", None),
'usergroup': loadedJob.get("ownerGroup", ''),
'userrole': loadedJob.get("ownerRole", ''),
'possibleSites': frozenset(possibleLocations), # abort and drain sites filtered out
'potentialSites': frozenset(potentialLocations), # original list of sites
'scramArch': loadedJob.get("scramArch", None),
'swVersion': loadedJob.get("swVersion", None),
'name': loadedJob["name"],
'proxyPath': loadedJob.get("proxyPath", None),
'estimatedJobTime': loadedJob.get("estimatedJobTime", None),
'estimatedDiskUsage': loadedJob.get("estimatedDiskUsage", None),
'estimatedMemoryUsage': loadedJob.get("estimatedMemoryUsage", None),
'numberOfCores': loadedJob.get("numberOfCores", 1), # may update it later
'inputDataset': loadedJob.get('inputDataset', None),
'inputDatasetLocations': loadedJob.get('inputDatasetLocations', None),
'allowOpportunistic': loadedJob.get('allowOpportunistic', False)}
self.jobDataCache[jobID] = jobInfo
# Register failures in submission
for errorCode in badJobs:
if badJobs[errorCode]:
logging.debug("The following jobs could not be submitted: %s, error code : %d", badJobs, errorCode)
self._handleSubmitFailedJobs(badJobs[errorCode], errorCode)
# If there are any leftover jobs, we want to get rid of them.
self.flushJobPackages()
# We need to remove any jobs from the cache that were not returned in
# the last call to the database.
jobIDsToPurge = self.cachedJobIDs - dbJobs
self._purgeJobsFromCache(jobIDsToPurge)
logging.info("Done pruning killed jobs, moving on to submit.")
return
def removeAbortedForceCompletedWorkflowFromCache(self):
abortedAndForceCompleteRequests = self.abortedAndForceCompleteWorkflowCache.getData()
jobIDsToPurge = set()
for jobID, jobInfo in self.jobDataCache.iteritems():
if (jobInfo['requestName'] in abortedAndForceCompleteRequests) and \
(jobInfo['taskType'] not in ['LogCollect', "Cleanup"]):
jobIDsToPurge.add(jobID)
self._purgeJobsFromCache(jobIDsToPurge)
return
def _purgeJobsFromCache(self, jobIDsToPurge):
if len(jobIDsToPurge) == 0:
return
self.cachedJobIDs -= jobIDsToPurge
for jobid in jobIDsToPurge:
self.jobDataCache.pop(jobid, None)
for jobPrio in self.cachedJobs:
if self.cachedJobs[jobPrio].pop(jobid, None):
# then the jobid was found, go to the next one
break
return
def _handleSubmitFailedJobs(self, badJobs, exitCode):
"""
__handleSubmitFailedJobs_
For a default job report for the exitCode
and register in the job. Preserve it on disk as well.
Propagate the failure to the JobStateMachine.
"""
fwjrBinds = []
for job in badJobs:
job['couch_record'] = None
job['fwjr'] = Report()
if exitCode in [71102, 71104]:
job['fwjr'].addError("JobSubmit", exitCode, "SubmitFailed", WM_JOB_ERROR_CODES[exitCode] + ', '.join(job['possibleLocations']))
elif exitCode in [71101]:
# there is no possible site
if job.get("fileLocations"):
job['fwjr'].addError("JobSubmit", exitCode, "SubmitFailed", WM_JOB_ERROR_CODES[exitCode] +
": file locations: " + ', '.join(job['fileLocations']) +
": site white list: " + ', '.join(job['siteWhitelist']) +
": site black list: " + ', '.join(job['siteBlacklist']))
else:
job['fwjr'].addError("JobSubmit", exitCode, "SubmitFailed", WM_JOB_ERROR_CODES[exitCode])
fwjrPath = os.path.join(job['cache_dir'],
'Report.%d.pkl' % int(job['retry_count']))
job['fwjr'].setJobID(job['id'])
try:
job['fwjr'].save(fwjrPath)
fwjrBinds.append({"jobid" : job["id"], "fwjrpath" : fwjrPath})
except IOError as ioer:
logging.error("Failed to write FWJR for submit failed job %d, message: %s", job['id'], str(ioer))
self.changeState.propagate(badJobs, "submitfailed", "created")
self.setFWJRPathAction.execute(binds=fwjrBinds)
return
def getThresholds(self):
"""
_getThresholds_
Retrieve submit thresholds, which considers what is pending and running
for those sites.
Also update the list of draining and abort/down sites.
Finally, creates a map between task type and its priority.
"""
self.taskTypePrioMap = {}
newDrainSites = set()
newAbortSites = set()
rcThresholds = self.resourceControl.listThresholdsForSubmit()
for siteName in rcThresholds.keys():
# Add threshold if we don't have it already
state = rcThresholds[siteName]["state"]
if state == "Draining":
newDrainSites.add(siteName)
if state in ["Down", "Aborted"]:
newAbortSites.add(siteName)
# then update the task type x task priority mapping
if not self.taskTypePrioMap:
for task, value in rcThresholds[siteName]['thresholds'].items():
self.taskTypePrioMap[task] = value.get('priority', 0) * self.maxTaskPriority
# When the list of drain/abort sites change between iteration then a location
# refresh is needed, for now it forces a full cache refresh
if newDrainSites != self.drainSites or newAbortSites != self.abortSites:
logging.info("Draining or Aborted sites have changed, the cache will be rebuilt.")
self.cachedJobIDs = set()
self.cachedJobs = {}
self.jobDataCache = {}
self.currentRcThresholds = rcThresholds
self.abortSites = newAbortSites
self.drainSites = newDrainSites
return
def _getJobSubmitCondition(self, jobPrio, siteName, jobType):
"""
returns the string describing whether a job is ready to be submitted or the reason can't be submitted
Only jobs with "JobSubmitReady" return value will be added to submit job.
Other return values will indicate the reason jobs cannot be submitted.
i.e. "NoPendingSlot" - pending slot is full with pending job
"""
try:
totalPendingSlots = self.currentRcThresholds[siteName]["total_pending_slots"]
totalPendingJobs = self.currentRcThresholds[siteName]["total_pending_jobs"]
totalRunningSlots = self.currentRcThresholds[siteName]["total_running_slots"]
totalRunningJobs = self.currentRcThresholds[siteName]["total_running_jobs"]
taskPendingSlots = self.currentRcThresholds[siteName]['thresholds'][jobType]["pending_slots"]
taskPendingJobs = self.currentRcThresholds[siteName]['thresholds'][jobType]["task_pending_jobs"]
taskRunningSlots = self.currentRcThresholds[siteName]['thresholds'][jobType]["max_slots"]
taskRunningJobs = self.currentRcThresholds[siteName]['thresholds'][jobType]["task_running_jobs"]
highestPriorityInJobs = self.currentRcThresholds[siteName]['thresholds'][jobType]['wf_highest_priority']
# set the initial totalPendingJobs since it increases in every cycle when a job is submitted
self.currentRcThresholds[siteName].setdefault("init_total_pending_jobs", totalPendingJobs)
# set the initial taskPendingJobs since it increases in every cycle when a job is submitted
self.currentRcThresholds[siteName]['thresholds'][jobType].setdefault("init_task_pending_jobs", taskPendingJobs)
initTotalPending = self.currentRcThresholds[siteName]["init_total_pending_jobs"]
initTaskPending = self.currentRcThresholds[siteName]['thresholds'][jobType]["init_task_pending_jobs"]
except KeyError as ex:
msg = "Invalid key for site %s and job type %s\n" % (siteName, jobType)
logging.exception(msg)
return "NoJobType_%s_%s" % (siteName, jobType)
if (highestPriorityInJobs is None) or (jobPrio <= highestPriorityInJobs) or (jobType in self.ioboundTypes):
# there is no pending or running jobs in the system (None case) or
# priority of the job is lower or equal don't allow overflow
# Also if jobType is in ioboundTypes don't allow overflow
totalPendingThreshold = totalPendingSlots
taskPendingThreshold = taskPendingSlots
totalJobThreshold = totalPendingSlots + totalRunningSlots
totalTaskTheshold = taskPendingSlots + taskRunningSlots
else:
# In case the priority of the job is higher than any of currently pending or running jobs.
# Then increase the threshold by condorOverflowFraction * original pending slot.
totalPendingThreshold = max(totalPendingSlots, initTotalPending) + (
totalPendingSlots * self.condorOverflowFraction)
taskPendingThreshold = max(taskPendingSlots, initTaskPending) + (
taskPendingSlots * self.condorOverflowFraction)
totalJobThreshold = totalPendingThreshold + totalRunningSlots
totalTaskTheshold = taskPendingThreshold + taskRunningSlots
jobStats = [{"Condition": "NoPendingSlot",
"Current": totalPendingJobs,
"Threshold": totalPendingThreshold},
{"Condition": "NoTaskPendingSlot",
"Current": taskPendingJobs,
"Threshold": taskPendingThreshold},
{"Condition": "NoRunningSlot",
"Current": totalPendingJobs + totalRunningJobs,
"Threshold": totalJobThreshold},
{"Condition": "NoTaskRunningSlot",
"Current": taskPendingJobs + taskRunningJobs,
"Threshold": totalTaskTheshold}]
return jobSubmitCondition(jobStats)
def assignJobLocations(self):
"""
_assignJobLocations_
Loop through the submit thresholds and pull sites out of the job cache
as we discover open slots. This will return a list of tuple where each
tuple will have six elements:
- WMBS Job ID
- Retry count
- Batch ID
- Path to sanbox
- Path to cache directory
- SE name of the site to run at
"""
jobsToSubmit = {}
jobsToUncache = []
jobsCount = 0
exitLoop = False
jobSubmitLogBySites = defaultdict(Counter)
jobSubmitLogByPriority = defaultdict(Counter)
# iterate over jobs from the highest to the lowest prio
for jobPrio in sorted(self.cachedJobs, reverse=True):
# then we're completely done and have our basket full of jobs to submit
if exitLoop:
break
# start eating through the elder jobs first
for job in sorted(self.cachedJobs[jobPrio].values(), key=itemgetter('timestamp')):
jobid = job['id']
jobType = job['type']
possibleSites = job['possibleLocations']
jobSubmitLogByPriority[jobPrio]['Total'] += 1
# now look for sites with free pending slots
for siteName in possibleSites:
if siteName not in self.currentRcThresholds:
logging.warn("Have a job for %s which is not in the resource control", siteName)
continue
condition = self._getJobSubmitCondition(jobPrio, siteName, jobType)
if condition != "JobSubmitReady":
jobSubmitLogBySites[siteName][condition] += 1
logging.debug("Found a job for %s : %s", siteName, condition)
continue
# otherwise, update the site/task thresholds and the component job counter
self.currentRcThresholds[siteName]["total_pending_jobs"] += 1
self.currentRcThresholds[siteName]['thresholds'][jobType]["task_pending_jobs"] += 1
jobsCount += 1
# load (and remove) the job dictionary object from jobDataCache
cachedJob = self.jobDataCache.pop(jobid)
jobsToUncache.append((jobPrio, jobid))
# Sort jobs by jobPackage
package = cachedJob['packageDir']
if package not in jobsToSubmit.keys():
jobsToSubmit[package] = []
# Add the sandbox to a global list
self.sandboxPackage[package] = cachedJob.pop('sandbox')
# Now update the job dictionary object
cachedJob['custom'] = {'location': siteName}
cachedJob['taskPriority'] = self.currentRcThresholds[siteName]['thresholds'][jobType]["priority"]
# Get this job in place to be submitted by the plugin
jobsToSubmit[package].append(cachedJob)
jobSubmitLogBySites[siteName]["submitted"] += 1
jobSubmitLogByPriority[jobPrio]['submitted'] += 1
# found a site to submit this job, so go to the next job
break
# set the flag and get out of the job iteration
if jobsCount >= self.maxJobsThisCycle:
logging.info("Submitter reached limit of submit slots for this cycle: %i", self.maxJobsThisCycle)
exitLoop = True
break
# jobs that are going to be submitted must be removed from all caches
for prio, jobid in jobsToUncache:
self.cachedJobs[prio].pop(jobid)
self.cachedJobIDs.remove(jobid)
logging.info("Site submission report: %s", dict(jobSubmitLogBySites))
logging.info("Priority submission report: %s", dict(jobSubmitLogByPriority))
logging.info("Have %s packages to submit.", len(jobsToSubmit))
logging.info("Have %s jobs to submit.", jobsCount)
logging.info("Done assigning site locations.")
return jobsToSubmit
def submitJobs(self, jobsToSubmit):
"""
_submitJobs_
Actually do the submission of the jobs
"""
jobList = []
idList = []
if len(jobsToSubmit) == 0:
logging.debug("There are no packages to submit.")
return
for package in jobsToSubmit.keys():
sandbox = self.sandboxPackage[package]
jobs = jobsToSubmit.get(package, [])
for job in jobs:
job['location'], job['plugin'], job['site_cms_name'] = self.getSiteInfo(job['custom']['location'])
job['sandbox'] = sandbox
idList.append({'jobid': job['id'], 'location': job['custom']['location']})
#Clean out the package reference
del self.sandboxPackage[package]
jobList.extend(jobs)
myThread = threading.currentThread()
myThread.transaction.begin()
# Run the actual underlying submit code using bossAir
successList, failList = self.bossAir.submit(jobs=jobList)
logging.info("Jobs that succeeded/failed submission: %d/%d.", len(successList), len(failList))
# Propagate states in the WMBS database
logging.debug("Propagating success state to WMBS.")
self.changeState.propagate(successList, 'executing', 'created')
logging.debug("Propagating fail state to WMBS.")
self.changeState.propagate(failList, 'submitfailed', 'created')
# At the end we mark the locations of the jobs
# This applies even to failed jobs, since the location
# could be part of the failure reason.
logging.debug("Updating job location...")
self.setLocationAction.execute(bulkList=idList, conn=myThread.transaction.conn,
transaction=True)
myThread.transaction.commit()
logging.info("Transaction cycle successfully completed.")
return
def getSiteInfo(self, jobSite):
"""
_getSiteInfo_
This is how you get the name of a CE and the plugin for a job
"""
if not jobSite in self.locationDict.keys():
siteInfo = self.locationAction.execute(siteName=jobSite)
self.locationDict[jobSite] = siteInfo[0]
return (self.locationDict[jobSite].get('ce_name'),
self.locationDict[jobSite].get('plugin'),
self.locationDict[jobSite].get('cms_name'))
@timeFunction
def algorithm(self, parameters=None):
"""
_algorithm_
Try to, in order:
1) Refresh the cache
2) Find jobs for all the necessary sites
3) Submit the jobs to the plugin
"""
myThread = threading.currentThread()
if self.useReqMgrForCompletionCheck:
# only runs when reqmgr is used (not Tier0)
self.removeAbortedForceCompletedWorkflowFromCache()
agentConfig = self.reqAuxDB.getWMAgentConfig(self.config.Agent.hostName)
self.condorFraction = agentConfig.get('CondorJobsFraction', 0.75)
self.condorOverflowFraction = agentConfig.get("CondorOverflowFraction", 0.2)
else:
# For Tier0 agent
self.condorFraction = 1
self.condorOverflowFraction = 0
if not self.passSubmitConditions():
msg = "JobSubmitter didn't pass the submit conditions. Skipping this cycle."
logging.warning(msg)
myThread.logdbClient.post("JobSubmitter_submitWork", msg, "warning")
return
try:
myThread.logdbClient.delete("JobSubmitter_submitWork", "warning", this_thread=True)
self.getThresholds()
self.refreshCache()
jobsToSubmit = self.assignJobLocations()
self.submitJobs(jobsToSubmit=jobsToSubmit)
except WMException:
if getattr(myThread, 'transaction', None) != None:
myThread.transaction.rollback()
raise
except Exception as ex:
msg = 'Fatal error in JobSubmitter:\n'
msg += str(ex)
#msg += str(traceback.format_exc())
msg += '\n\n'
logging.error(msg)
if getattr(myThread, 'transaction', None) != None:
myThread.transaction.rollback()
raise JobSubmitterPollerException(msg)
return
def passSubmitConditions(self):
"""
_passSubmitConditions_
Check whether the component is allowed to submit jobs to condor.
Initially it has only one condition, which is the total number of
jobs we can have in condor (pending + running) per schedd, set by
MAX_JOBS_PER_OWNER.
"""
myThread = threading.currentThread()
freeSubmitSlots = availableScheddSlots(dbi=myThread.dbi, logger=logging,
condorFraction=self.condorFraction)
self.maxJobsThisCycle = min(freeSubmitSlots, self.maxJobsPerPoll)
return (freeSubmitSlots > 0)
def terminate(self, params):
"""
_terminate_
Kill the code after one final pass when called by the master thread.
"""
logging.debug("terminating. doing one more pass before we die")
self.algorithm(params)
def __init__(self, config=None):
self.config = config
self.reqmgrAux = ReqMgrAux(self.config.reqmgr2_url)
self.requests = {}
self.reqManager = RequestManager()
self.taskManager = TaskManager(nworkers=3)
def __init__(self, config):
BaseWorkerThread.__init__(self)
myThread = threading.currentThread()
self.config = config
#DAO factory for WMBS objects
self.daoFactory = DAOFactory(package="WMCore.WMBS", logger=logging, dbinterface=myThread.dbi)
#Libraries
self.resourceControl = ResourceControl()
self.changeState = ChangeState(self.config)
self.bossAir = BossAirAPI(config=self.config)
self.hostName = self.config.Agent.hostName
self.repollCount = getattr(self.config.JobSubmitter, 'repollCount', 10000)
self.maxJobsPerPoll = int(getattr(self.config.JobSubmitter, 'maxJobsPerPoll', 1000))
self.maxJobsThisCycle = self.maxJobsPerPoll # changes as per schedd limit
self.cacheRefreshSize = int(getattr(self.config.JobSubmitter, 'cacheRefreshSize', 30000))
self.skipRefreshCount = int(getattr(self.config.JobSubmitter, 'skipRefreshCount', 20))
self.packageSize = getattr(self.config.JobSubmitter, 'packageSize', 500)
self.collSize = getattr(self.config.JobSubmitter, 'collectionSize', self.packageSize * 1000)
self.maxTaskPriority = getattr(self.config.BossAir, 'maxTaskPriority', 1e7)
self.condorFraction = 0.75 # update during every algorithm cycle
self.condorOverflowFraction = 0.2
self.ioboundTypes = ('LogCollect', 'Merge', 'Cleanup', 'Harvesting')
# Additions for caching-based JobSubmitter
self.cachedJobIDs = set()
self.cachedJobs = {}
self.jobDataCache = {}
self.jobsToPackage = {}
self.sandboxPackage = {}
self.locationDict = {}
self.taskTypePrioMap = {}
self.drainSites = set()
self.abortSites = set()
self.refreshPollingCount = 0
try:
if not getattr(self.config.JobSubmitter, 'submitDir', None):
self.config.JobSubmitter.submitDir = self.config.JobSubmitter.componentDir
self.packageDir = os.path.join(self.config.JobSubmitter.submitDir, 'packages')
if not os.path.exists(self.packageDir):
os.makedirs(self.packageDir)
except OSError as ex:
msg = "Error while trying to create packageDir %s\n!"
msg += str(ex)
logging.error(msg)
logging.debug("PackageDir: %s", self.packageDir)
logging.debug("Config: %s", config)
raise JobSubmitterPollerException(msg)
# Now the DAOs
self.listJobsAction = self.daoFactory(classname="Jobs.ListForSubmitter")
self.setLocationAction = self.daoFactory(classname="Jobs.SetLocation")
self.locationAction = self.daoFactory(classname="Locations.GetSiteInfo")
self.setFWJRPathAction = self.daoFactory(classname="Jobs.SetFWJRPath")
self.listWorkflows = self.daoFactory(classname="Workflow.ListForSubmitter")
# Keep a record of the thresholds in memory
self.currentRcThresholds = {}
self.useReqMgrForCompletionCheck = getattr(self.config.TaskArchiver, 'useReqMgrForCompletionCheck', True)
if self.useReqMgrForCompletionCheck:
# only set up this when reqmgr is used (not Tier0)
self.reqmgr2Svc = ReqMgr(self.config.General.ReqMgr2ServiceURL)
self.abortedAndForceCompleteWorkflowCache = self.reqmgr2Svc.getAbortedAndForceCompleteRequestsFromMemoryCache()
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
else:
# Tier0 Case - just for the clarity (This private variable shouldn't be used
self.abortedAndForceCompleteWorkflowCache = None
return
class DrainStatusPoller(BaseWorkerThread):
"""
Collects information related to the agent drain status
"""
# class variable that contains drain statistics
drainStats = {}
def __init__(self, config):
"""
initialize properties specified from config
"""
BaseWorkerThread.__init__(self)
self.config = config
self.drainAPI = DrainStatusAPI(config)
self.condorAPI = PyCondorAPI()
self.agentConfig = {}
self.previousConfig = {}
self.validSpeedDrainConfigKeys = [
'CondorPriority', 'NoJobRetries', 'EnableAllSites'
]
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
self.emailAlert = EmailAlert(config.EmailAlert.dictionary_())
self.condorStates = ("Running", "Idle")
@timeFunction
def algorithm(self, parameters):
"""
Update drainStats if agent is in drain mode
"""
logging.info("Running agent drain algorithm...")
if self.agentConfig:
# make a copy of the previous agent aux db configuration to compare against later
self.previousConfig = copy.deepcopy(self.agentConfig)
# grab a new copy of the agent aux db configuration
self.agentConfig = self.reqAuxDB.getWMAgentConfig(
self.config.Agent.hostName)
if not self.agentConfig:
logging.error(
"Failed to fetch agent configuration from the auxiliary DB")
return
try:
# see if the agent is in drain mode
if self.agentConfig["UserDrainMode"] or self.agentConfig[
"AgentDrainMode"]:
# check to see if the agent hit any speed drain thresholds
thresholdsHit = self.checkSpeedDrainThresholds()
if thresholdsHit:
logging.info(
"Updating agent configuration for speed drain...")
self.updateAgentSpeedDrainConfig(thresholdsHit)
# now collect drain statistics
DrainStatusPoller.drainStats = self.drainAPI.collectDrainInfo()
logging.info("Finished collecting agent drain status.")
logging.info("Drain stats: %s",
str(DrainStatusPoller.drainStats))
else:
logging.info(
"Agent not in drain mode. Resetting flags and skipping drain check..."
)
self.resetAgentSpeedDrainConfig()
# finally, check for any changes in drain status
self.checkDrainStatusChanges()
except Exception as ex:
msg = "Error occurred, will retry later:\n"
msg += str(ex)
logging.exception(msg)
@classmethod
def getDrainInfo(cls):
"""
Return drainStats class variable
"""
return cls.drainStats
def checkDrainStatusChanges(self):
"""
Check to see if any drain statuses have changed in the auxiliary db
If yes, send email notification and update local drain thread variables
"""
message = ""
drainStatusKeys = ['UserDrainMode', 'AgentDrainMode', 'SpeedDrainMode']
if not self.previousConfig:
return
for key in drainStatusKeys:
if self.previousConfig[key] != self.agentConfig[key]:
message += "Agent had a drain status transition to %s = %s\n" % (
str(key), str(self.agentConfig[key]))
if message:
self.emailAlert.send(
"DrainMode status change on " +
getattr(self.config.Agent, "hostName"), message)
logging.info("Drain mode status change: %s", message)
return
def updateAgentSpeedDrainConfig(self, thresholdsHit):
"""
Takes a list of speed drain configuration keys and updates the agent configuration
"""
updateConfig = False
condorPriorityFlag = False
speedDrainConfig = self.agentConfig.get("SpeedDrainConfig")
if 'CondorPriority' in thresholdsHit:
logging.info(
"Bumping condor job priority to 999999 for Production/Processing pending jobs."
)
self.condorAPI.editCondorJobs(
"JobStatus=?=1 && (CMS_JobType =?= \"Production\" || CMS_JobType =?= \"Processing\")",
"JobPrio", "999999")
condorPriorityFlag = True
if condorPriorityFlag != speedDrainConfig['CondorPriority']['Enabled']:
# CondorPriority setting is irreversible so the flag only indicates weather
# priority is increased or not. It is not checked by other components
logging.info("Enabling CondorPriority flag.")
speedDrainConfig['CondorPriority']['Enabled'] = condorPriorityFlag
updateConfig = True
if 'NoJobRetries' in thresholdsHit:
logging.info(
"Enabling NoJobRetries flag: Error Handler won't retry the jobs"
)
# ErrorHandler will pick this up and set max retries to 0
speedDrainConfig['NoJobRetries']['Enabled'] = True
updateConfig = True
if 'EnableAllSites' in thresholdsHit:
logging.info(
"Enabling EnableAllSites flag: Updating agent to submit to all sites."
)
# setting this value to True makes JobSubmitterPoller ignore site status
speedDrainConfig['EnableAllSites']['Enabled'] = True
updateConfig = True
# update the aux db speed drain config with any changes
if updateConfig:
self.agentConfig['SpeedDrainMode'] = True
self.reqAuxDB.updateWMAgentConfig(self.config.Agent.hostName,
self.agentConfig)
return
def resetAgentSpeedDrainConfig(self):
"""
resetting SpeedDrainMode to False and SpeedDrainConfig Enabled to False
"""
if self.agentConfig.get("SpeedDrainMode"):
self.agentConfig['SpeedDrainMode'] = False
speedDrainConfig = self.agentConfig.get("SpeedDrainConfig")
for key, v in viewitems(speedDrainConfig):
if key in self.validSpeedDrainConfigKeys and v['Enabled']:
speedDrainConfig[key]['Enabled'] = False
self.reqAuxDB.updateWMAgentConfig(self.config.Agent.hostName,
self.agentConfig)
return
def checkSpeedDrainThresholds(self):
"""
Check the current number of jobs in Condor and create a list of agent configuration parameters
that need updated for speed draining
"""
enableKeys = []
# first, update our summary of condor jobs
totalJobs = self.getTotalCondorJobs()
if totalJobs is None:
msg = "Cannot check speed drain because there was an error fetching job summary from HTCondor."
msg += " Will retry again in the next cycle."
logging.warning(msg)
return []
# get the current speed drain status
speedDrainConfig = self.agentConfig.get("SpeedDrainConfig")
# loop through the speed drain configuration and make a list of what thresholds have been hit
for k, v in viewitems(speedDrainConfig):
# make sure keys in the speed drain config are valid
if k in self.validSpeedDrainConfigKeys and isinstance(
v['Threshold'], int) and isinstance(v['Enabled'], bool):
# we always want to apply the condor priority change if the threshold is hit
if not v['Enabled'] or k == 'CondorPriority':
logging.info("Checking speed drain threshold for %s. ", k)
if totalJobs < v['Threshold']:
logging.info(
"Agent will update speed drain configuration for %s. ",
k)
enableKeys.append(k)
else:
logging.warning(
"Speed drain configuration error for %s. Please check aux db contents.",
k)
return enableKeys
def getTotalCondorJobs(self):
"""
Retrieve a summary of the jobs in condor and return an absolute number
of the jobs in Idle and Running states.
:return: returns an integer with the total number of jobs, or None if it failed.
"""
jobs = self.condorAPI.getCondorJobsSummary()
if not jobs:
return None
results = 0
if jobs:
for state in self.condorStates:
results += int(jobs[0].get(state))
return results
class JobSubmitterPoller(BaseWorkerThread):
"""
_JobSubmitterPoller_
The jobSubmitterPoller takes the jobs and organizes them into packages
before sending them to the individual plugin submitters.
"""
def __init__(self, config):
BaseWorkerThread.__init__(self)
myThread = threading.currentThread()
self.config = config
#DAO factory for WMBS objects
self.daoFactory = DAOFactory(package="WMCore.WMBS",
logger=logging,
dbinterface=myThread.dbi)
#Libraries
self.resourceControl = ResourceControl()
self.changeState = ChangeState(self.config)
self.bossAir = BossAirAPI(config=self.config)
self.hostName = self.config.Agent.hostName
self.repollCount = getattr(self.config.JobSubmitter, 'repollCount',
10000)
self.maxJobsPerPoll = int(
getattr(self.config.JobSubmitter, 'maxJobsPerPoll', 1000))
self.maxJobsThisCycle = self.maxJobsPerPoll # changes as per schedd limit
self.cacheRefreshSize = int(
getattr(self.config.JobSubmitter, 'cacheRefreshSize', 30000))
self.skipRefreshCount = int(
getattr(self.config.JobSubmitter, 'skipRefreshCount', 20))
self.packageSize = getattr(self.config.JobSubmitter, 'packageSize',
500)
self.collSize = getattr(self.config.JobSubmitter, 'collectionSize',
self.packageSize * 1000)
self.maxTaskPriority = getattr(self.config.BossAir, 'maxTaskPriority',
1e7)
self.condorFraction = 0.75 # update during every algorithm cycle
self.condorOverflowFraction = 0.2
self.ioboundTypes = ('LogCollect', 'Merge', 'Cleanup', 'Harvesting')
# Additions for caching-based JobSubmitter
self.cachedJobIDs = set()
self.cachedJobs = {}
self.jobDataCache = {}
self.jobsToPackage = {}
self.sandboxPackage = {}
self.locationDict = {}
self.taskTypePrioMap = {}
self.drainSites = set()
self.abortSites = set()
self.refreshPollingCount = 0
try:
if not getattr(self.config.JobSubmitter, 'submitDir', None):
self.config.JobSubmitter.submitDir = self.config.JobSubmitter.componentDir
self.packageDir = os.path.join(self.config.JobSubmitter.submitDir,
'packages')
if not os.path.exists(self.packageDir):
os.makedirs(self.packageDir)
except OSError as ex:
msg = "Error while trying to create packageDir %s\n!"
msg += str(ex)
logging.error(msg)
logging.debug("PackageDir: %s", self.packageDir)
logging.debug("Config: %s", config)
raise JobSubmitterPollerException(msg)
# Now the DAOs
self.listJobsAction = self.daoFactory(
classname="Jobs.ListForSubmitter")
self.setLocationAction = self.daoFactory(classname="Jobs.SetLocation")
self.locationAction = self.daoFactory(
classname="Locations.GetSiteInfo")
self.setFWJRPathAction = self.daoFactory(classname="Jobs.SetFWJRPath")
self.listWorkflows = self.daoFactory(
classname="Workflow.ListForSubmitter")
# Keep a record of the thresholds in memory
self.currentRcThresholds = {}
self.useReqMgrForCompletionCheck = getattr(
self.config.TaskArchiver, 'useReqMgrForCompletionCheck', True)
if self.useReqMgrForCompletionCheck:
# only set up this when reqmgr is used (not Tier0)
self.reqmgr2Svc = ReqMgr(self.config.General.ReqMgr2ServiceURL)
self.abortedAndForceCompleteWorkflowCache = self.reqmgr2Svc.getAbortedAndForceCompleteRequestsFromMemoryCache(
)
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
else:
# Tier0 Case - just for the clarity (This private variable shouldn't be used
self.abortedAndForceCompleteWorkflowCache = None
return
def getPackageCollection(self, sandboxDir):
"""
_getPackageCollection_
Given a jobID figure out which packageCollection
it should belong in.
"""
rawList = os.listdir(sandboxDir)
collections = []
numberList = []
for entry in rawList:
if 'PackageCollection' in entry:
collections.append(entry)
# If we have no collections, return 0 (PackageCollection_0)
if len(collections) < 1:
return 0
# Loop over the list of PackageCollections
for collection in collections:
collectionPath = os.path.join(sandboxDir, collection)
packageList = os.listdir(collectionPath)
collectionNum = int(collection.split('_')[1])
if len(packageList) < self.collSize:
return collectionNum
else:
numberList.append(collectionNum)
# If we got here, then all collections are full. We'll need
# a new one. Find the highest number, increment by one
numberList.sort()
return numberList[-1] + 1
def addJobsToPackage(self, loadedJob):
"""
_addJobsToPackage_
Add a job to a job package and then return the batch ID for the job.
Packages are only written out to disk when they contain 100 jobs. The
flushJobsPackages() method must be called after all jobs have been added
to the cache and before they are actually submitted to make sure all the
job packages have been written to disk.
"""
if loadedJob["workflow"] not in self.jobsToPackage:
# First, let's pull all the information from the loadedJob
batchid = "%s-%s" % (loadedJob["id"], loadedJob["retry_count"])
sandboxDir = os.path.dirname(loadedJob["sandbox"])
# Second, assemble the jobPackage location
collectionIndex = self.getPackageCollection(sandboxDir)
collectionDir = os.path.join(
sandboxDir, 'PackageCollection_%i' % collectionIndex,
'batch_%s' % batchid)
# Now create the package object
self.jobsToPackage[loadedJob["workflow"]] = {
"batchid": batchid,
'id': loadedJob['id'],
"package": JobPackage(directory=collectionDir)
}
jobPackage = self.jobsToPackage[loadedJob["workflow"]]["package"]
jobPackage[loadedJob["id"]] = loadedJob.getDataStructsJob()
batchDir = jobPackage['directory']
if len(jobPackage.keys()) == self.packageSize:
if not os.path.exists(batchDir):
os.makedirs(batchDir)
batchPath = os.path.join(batchDir, "JobPackage.pkl")
jobPackage.save(batchPath)
del self.jobsToPackage[loadedJob["workflow"]]
return batchDir
def flushJobPackages(self):
"""
_flushJobPackages_
Write any jobs packages to disk that haven't been written out already.
"""
workflowNames = self.jobsToPackage.keys()
for workflowName in workflowNames:
jobPackage = self.jobsToPackage[workflowName]["package"]
batchDir = jobPackage['directory']
if not os.path.exists(batchDir):
os.makedirs(batchDir)
batchPath = os.path.join(batchDir, "JobPackage.pkl")
jobPackage.save(batchPath)
del self.jobsToPackage[workflowName]
return
def refreshCache(self):
"""
_refreshCache_
Query WMBS for all jobs in the 'created' state. For all jobs returned
from the query, check if they already exist in the cache. If they
don't, unpickle them and combine their site white and black list with
the list of locations they can run at. Add them to the cache.
Each entry in the cache is a tuple with five items:
- WMBS Job ID
- Retry count
- Batch ID
- Path to sanbox
- Path to cache directory
"""
badJobs = dict([(x, []) for x in range(71101, 71105)])
dbJobs = set()
logging.info("Refreshing priority cache with currently %i jobs",
len(self.cachedJobIDs))
if self.cacheRefreshSize == -1 or len(self.cachedJobIDs) < self.cacheRefreshSize or \
self.refreshPollingCount >= self.skipRefreshCount:
newJobs = self.listJobsAction.execute()
self.refreshPollingCount = 0
if self.useReqMgrForCompletionCheck:
# if reqmgr is used (not Tier0 Agent) get the aborted/forceCompleted record
abortedAndForceCompleteRequests = self.abortedAndForceCompleteWorkflowCache.getData(
)
else:
#T0Agent
abortedAndForceCompleteRequests = []
logging.info("Found %s new jobs to be submitted.", len(newJobs))
else:
self.refreshPollingCount += 1
newJobs = []
dbJobs = self.cachedJobIDs
abortedAndForceCompleteRequests = []
logging.info(
"Skipping cache update to be submitted. (%s job in cache)",
len(dbJobs))
logging.info("Determining possible sites for new jobs...")
jobCount = 0
for newJob in newJobs:
# whether newJob belongs to aborted or force-complete workflow, and skip it if it is.
if (newJob['request_name'] in abortedAndForceCompleteRequests) and \
(newJob['type'] not in ['LogCollect', "Cleanup"]):
continue
jobID = newJob['id']
dbJobs.add(jobID)
if jobID in self.cachedJobIDs:
continue
jobCount += 1
if jobCount % 5000 == 0:
logging.info("Processed %d/%d new jobs.", jobCount,
len(newJobs))
pickledJobPath = os.path.join(newJob["cache_dir"], "job.pkl")
if not os.path.isfile(pickledJobPath):
# Then we have a problem - there's no file
logging.error("Could not find pickled jobObject %s",
pickledJobPath)
badJobs[71103].append(newJob)
continue
try:
jobHandle = open(pickledJobPath, "r")
loadedJob = pickle.load(jobHandle)
jobHandle.close()
except Exception as ex:
msg = "Error while loading pickled job object %s\n" % pickledJobPath
msg += str(ex)
logging.error(msg)
raise JobSubmitterPollerException(msg)
loadedJob['retry_count'] = newJob['retry_count']
# figure out possible locations for job
possibleLocations = loadedJob["possiblePSN"]
# Create another set of locations that may change when a site goes white/black listed
# Does not care about the non_draining or aborted sites, they may change and that is the point
potentialLocations = set()
potentialLocations.update(possibleLocations)
# now check for sites in drain and adjust the possible locations
# also check if there is at least one site left to run the job
if len(possibleLocations) == 0:
newJob['name'] = loadedJob['name']
newJob['fileLocations'] = loadedJob.get('fileLocations', [])
newJob['siteWhitelist'] = loadedJob.get('siteWhitelist', [])
newJob['siteBlacklist'] = loadedJob.get('siteBlacklist', [])
badJobs[71101].append(newJob)
continue
else:
nonAbortSites = [
x for x in possibleLocations if x not in self.abortSites
]
if nonAbortSites: # if there is at least a non aborted/down site then run there, otherwise fail the job
possibleLocations = nonAbortSites
else:
newJob['name'] = loadedJob['name']
newJob['possibleLocations'] = possibleLocations
badJobs[71102].append(newJob)
continue
# try to remove draining sites if possible, this is needed to stop
# jobs that could run anywhere blocking draining sites
# if the job type is Merge, LogCollect or Cleanup this is skipped
if newJob['type'] not in self.ioboundTypes:
nonDrainingSites = [
x for x in possibleLocations if x not in self.drainSites
]
if nonDrainingSites: # if >1 viable non-draining site remove draining ones
possibleLocations = nonDrainingSites
else:
newJob['name'] = loadedJob['name']
newJob['possibleLocations'] = possibleLocations
badJobs[71104].append(newJob)
continue
# locations clear of abort and draining sites
newJob['possibleLocations'] = possibleLocations
batchDir = self.addJobsToPackage(loadedJob)
self.cachedJobIDs.add(jobID)
# calculate the final job priority such that we can order cached jobs by prio
jobPrio = self.taskTypePrioMap.get(newJob['type'],
0) + newJob['wf_priority']
if jobPrio not in self.cachedJobs:
self.cachedJobs[jobPrio] = {}
# now add basic information keyed by the jobid
self.cachedJobs[jobPrio][jobID] = newJob
# allow job baggage to override numberOfCores
# => used for repacking to get more slots/disk
numberOfCores = loadedJob.get('numberOfCores', 1)
if numberOfCores == 1:
baggage = loadedJob.getBaggage()
numberOfCores = getattr(baggage, "numberOfCores", 1)
loadedJob['numberOfCores'] = numberOfCores
# Create a job dictionary object and put it in the cache (needs to be in sync with RunJob)
jobInfo = {
'id':
jobID,
'requestName':
newJob['request_name'],
'taskName':
newJob['task_name'],
'taskType':
newJob['type'],
'cache_dir':
newJob["cache_dir"],
'priority':
newJob['wf_priority'],
'taskID':
newJob['task_id'],
'retry_count':
newJob["retry_count"],
'taskPriority':
None, # update from the thresholds
'custom': {
'location': None
}, # update later
'packageDir':
batchDir,
'sandbox':
loadedJob["sandbox"], # remove before submit
'userdn':
loadedJob.get("ownerDN", None),
'usergroup':
loadedJob.get("ownerGroup", ''),
'userrole':
loadedJob.get("ownerRole", ''),
'possibleSites':
frozenset(
possibleLocations), # abort and drain sites filtered out
'potentialSites':
frozenset(potentialLocations), # original list of sites
'scramArch':
loadedJob.get("scramArch", None),
'swVersion':
loadedJob.get("swVersion", None),
'name':
loadedJob["name"],
'proxyPath':
loadedJob.get("proxyPath", None),
'estimatedJobTime':
loadedJob.get("estimatedJobTime", None),
'estimatedDiskUsage':
loadedJob.get("estimatedDiskUsage", None),
'estimatedMemoryUsage':
loadedJob.get("estimatedMemoryUsage", None),
'numberOfCores':
loadedJob.get("numberOfCores", 1), # may update it later
'inputDataset':
loadedJob.get('inputDataset', None),
'inputDatasetLocations':
loadedJob.get('inputDatasetLocations', None),
'allowOpportunistic':
loadedJob.get('allowOpportunistic', False)
}
self.jobDataCache[jobID] = jobInfo
# Register failures in submission
for errorCode in badJobs:
if badJobs[errorCode]:
logging.debug(
"The following jobs could not be submitted: %s, error code : %d",
badJobs, errorCode)
self._handleSubmitFailedJobs(badJobs[errorCode], errorCode)
# If there are any leftover jobs, we want to get rid of them.
self.flushJobPackages()
# We need to remove any jobs from the cache that were not returned in
# the last call to the database.
jobIDsToPurge = self.cachedJobIDs - dbJobs
self._purgeJobsFromCache(jobIDsToPurge)
logging.info("Done pruning killed jobs, moving on to submit.")
return
def removeAbortedForceCompletedWorkflowFromCache(self):
abortedAndForceCompleteRequests = self.abortedAndForceCompleteWorkflowCache.getData(
)
jobIDsToPurge = set()
for jobID, jobInfo in self.jobDataCache.iteritems():
if (jobInfo['requestName'] in abortedAndForceCompleteRequests) and \
(jobInfo['taskType'] not in ['LogCollect', "Cleanup"]):
jobIDsToPurge.add(jobID)
self._purgeJobsFromCache(jobIDsToPurge)
return
def _purgeJobsFromCache(self, jobIDsToPurge):
if len(jobIDsToPurge) == 0:
return
self.cachedJobIDs -= jobIDsToPurge
for jobid in jobIDsToPurge:
self.jobDataCache.pop(jobid, None)
for jobPrio in self.cachedJobs:
if self.cachedJobs[jobPrio].pop(jobid, None):
# then the jobid was found, go to the next one
break
return
def _handleSubmitFailedJobs(self, badJobs, exitCode):
"""
__handleSubmitFailedJobs_
For a default job report for the exitCode
and register in the job. Preserve it on disk as well.
Propagate the failure to the JobStateMachine.
"""
fwjrBinds = []
for job in badJobs:
job['couch_record'] = None
job['fwjr'] = Report()
if exitCode in [71102, 71104]:
job['fwjr'].addError(
"JobSubmit", exitCode, "SubmitFailed",
WM_JOB_ERROR_CODES[exitCode] +
', '.join(job['possibleLocations']))
elif exitCode in [71101]:
# there is no possible site
if job.get("fileLocations"):
job['fwjr'].addError(
"JobSubmit", exitCode, "SubmitFailed",
WM_JOB_ERROR_CODES[exitCode] + ": file locations: " +
', '.join(job['fileLocations']) +
": site white list: " +
', '.join(job['siteWhitelist']) +
": site black list: " +
', '.join(job['siteBlacklist']))
else:
job['fwjr'].addError("JobSubmit", exitCode, "SubmitFailed",
WM_JOB_ERROR_CODES[exitCode])
fwjrPath = os.path.join(job['cache_dir'],
'Report.%d.pkl' % int(job['retry_count']))
job['fwjr'].setJobID(job['id'])
try:
job['fwjr'].save(fwjrPath)
fwjrBinds.append({"jobid": job["id"], "fwjrpath": fwjrPath})
except IOError as ioer:
logging.error(
"Failed to write FWJR for submit failed job %d, message: %s",
job['id'], str(ioer))
self.changeState.propagate(badJobs, "submitfailed", "created")
self.setFWJRPathAction.execute(binds=fwjrBinds)
return
def getThresholds(self):
"""
_getThresholds_
Retrieve submit thresholds, which considers what is pending and running
for those sites.
Also update the list of draining and abort/down sites.
Finally, creates a map between task type and its priority.
"""
self.taskTypePrioMap = {}
newDrainSites = set()
newAbortSites = set()
rcThresholds = self.resourceControl.listThresholdsForSubmit()
for siteName in rcThresholds.keys():
# Add threshold if we don't have it already
state = rcThresholds[siteName]["state"]
if state == "Draining":
newDrainSites.add(siteName)
if state in ["Down", "Aborted"]:
newAbortSites.add(siteName)
# then update the task type x task priority mapping
if not self.taskTypePrioMap:
for task, value in rcThresholds[siteName]['thresholds'].items(
):
self.taskTypePrioMap[task] = value.get(
'priority', 0) * self.maxTaskPriority
# When the list of drain/abort sites change between iteration then a location
# refresh is needed, for now it forces a full cache refresh
if newDrainSites != self.drainSites or newAbortSites != self.abortSites:
logging.info(
"Draining or Aborted sites have changed, the cache will be rebuilt."
)
self.cachedJobIDs = set()
self.cachedJobs = {}
self.jobDataCache = {}
self.currentRcThresholds = rcThresholds
self.abortSites = newAbortSites
self.drainSites = newDrainSites
return
def _getJobSubmitCondition(self, jobPrio, siteName, jobType):
"""
returns the string describing whether a job is ready to be submitted or the reason can't be submitted
Only jobs with "JobSubmitReady" return value will be added to submit job.
Other return values will indicate the reason jobs cannot be submitted.
i.e. "NoPendingSlot" - pending slot is full with pending job
"""
try:
totalPendingSlots = self.currentRcThresholds[siteName][
"total_pending_slots"]
totalPendingJobs = self.currentRcThresholds[siteName][
"total_pending_jobs"]
totalRunningSlots = self.currentRcThresholds[siteName][
"total_running_slots"]
totalRunningJobs = self.currentRcThresholds[siteName][
"total_running_jobs"]
taskPendingSlots = self.currentRcThresholds[siteName][
'thresholds'][jobType]["pending_slots"]
taskPendingJobs = self.currentRcThresholds[siteName]['thresholds'][
jobType]["task_pending_jobs"]
taskRunningSlots = self.currentRcThresholds[siteName][
'thresholds'][jobType]["max_slots"]
taskRunningJobs = self.currentRcThresholds[siteName]['thresholds'][
jobType]["task_running_jobs"]
highestPriorityInJobs = self.currentRcThresholds[siteName][
'thresholds'][jobType]['wf_highest_priority']
# set the initial totalPendingJobs since it increases in every cycle when a job is submitted
self.currentRcThresholds[siteName].setdefault(
"init_total_pending_jobs", totalPendingJobs)
# set the initial taskPendingJobs since it increases in every cycle when a job is submitted
self.currentRcThresholds[siteName]['thresholds'][
jobType].setdefault("init_task_pending_jobs", taskPendingJobs)
initTotalPending = self.currentRcThresholds[siteName][
"init_total_pending_jobs"]
initTaskPending = self.currentRcThresholds[siteName]['thresholds'][
jobType]["init_task_pending_jobs"]
except KeyError as ex:
msg = "Invalid key for site %s and job type %s\n" % (siteName,
jobType)
logging.exception(msg)
return "NoJobType_%s_%s" % (siteName, jobType)
if (highestPriorityInJobs is None) or (
jobPrio <= highestPriorityInJobs) or (jobType
in self.ioboundTypes):
# there is no pending or running jobs in the system (None case) or
# priority of the job is lower or equal don't allow overflow
# Also if jobType is in ioboundTypes don't allow overflow
totalPendingThreshold = totalPendingSlots
taskPendingThreshold = taskPendingSlots
totalJobThreshold = totalPendingSlots + totalRunningSlots
totalTaskTheshold = taskPendingSlots + taskRunningSlots
else:
# In case the priority of the job is higher than any of currently pending or running jobs.
# Then increase the threshold by condorOverflowFraction * original pending slot.
totalPendingThreshold = max(
totalPendingSlots, initTotalPending) + (
totalPendingSlots * self.condorOverflowFraction)
taskPendingThreshold = max(taskPendingSlots, initTaskPending) + (
taskPendingSlots * self.condorOverflowFraction)
totalJobThreshold = totalPendingThreshold + totalRunningSlots
totalTaskTheshold = taskPendingThreshold + taskRunningSlots
jobStats = [{
"Condition": "NoPendingSlot",
"Current": totalPendingJobs,
"Threshold": totalPendingThreshold
}, {
"Condition": "NoTaskPendingSlot",
"Current": taskPendingJobs,
"Threshold": taskPendingThreshold
}, {
"Condition": "NoRunningSlot",
"Current": totalPendingJobs + totalRunningJobs,
"Threshold": totalJobThreshold
}, {
"Condition": "NoTaskRunningSlot",
"Current": taskPendingJobs + taskRunningJobs,
"Threshold": totalTaskTheshold
}]
return jobSubmitCondition(jobStats)
def assignJobLocations(self):
"""
_assignJobLocations_
Loop through the submit thresholds and pull sites out of the job cache
as we discover open slots. This will return a list of tuple where each
tuple will have six elements:
- WMBS Job ID
- Retry count
- Batch ID
- Path to sanbox
- Path to cache directory
- SE name of the site to run at
"""
jobsToSubmit = {}
jobsToUncache = []
jobsCount = 0
exitLoop = False
jobSubmitLogBySites = defaultdict(Counter)
jobSubmitLogByPriority = defaultdict(Counter)
# iterate over jobs from the highest to the lowest prio
for jobPrio in sorted(self.cachedJobs, reverse=True):
# then we're completely done and have our basket full of jobs to submit
if exitLoop:
break
# start eating through the elder jobs first
for job in sorted(self.cachedJobs[jobPrio].values(),
key=itemgetter('timestamp')):
jobid = job['id']
jobType = job['type']
possibleSites = job['possibleLocations']
jobSubmitLogByPriority[jobPrio]['Total'] += 1
# now look for sites with free pending slots
for siteName in possibleSites:
if siteName not in self.currentRcThresholds:
logging.warn(
"Have a job for %s which is not in the resource control",
siteName)
continue
condition = self._getJobSubmitCondition(
jobPrio, siteName, jobType)
if condition != "JobSubmitReady":
jobSubmitLogBySites[siteName][condition] += 1
logging.debug("Found a job for %s : %s", siteName,
condition)
continue
# otherwise, update the site/task thresholds and the component job counter
self.currentRcThresholds[siteName][
"total_pending_jobs"] += 1
self.currentRcThresholds[siteName]['thresholds'][jobType][
"task_pending_jobs"] += 1
jobsCount += 1
# load (and remove) the job dictionary object from jobDataCache
cachedJob = self.jobDataCache.pop(jobid)
jobsToUncache.append((jobPrio, jobid))
# Sort jobs by jobPackage
package = cachedJob['packageDir']
if package not in jobsToSubmit.keys():
jobsToSubmit[package] = []
# Add the sandbox to a global list
self.sandboxPackage[package] = cachedJob.pop('sandbox')
# Now update the job dictionary object
cachedJob['custom'] = {'location': siteName}
cachedJob['taskPriority'] = self.currentRcThresholds[
siteName]['thresholds'][jobType]["priority"]
# Get this job in place to be submitted by the plugin
jobsToSubmit[package].append(cachedJob)
jobSubmitLogBySites[siteName]["submitted"] += 1
jobSubmitLogByPriority[jobPrio]['submitted'] += 1
# found a site to submit this job, so go to the next job
break
# set the flag and get out of the job iteration
if jobsCount >= self.maxJobsThisCycle:
logging.info(
"Submitter reached limit of submit slots for this cycle: %i",
self.maxJobsThisCycle)
exitLoop = True
break
# jobs that are going to be submitted must be removed from all caches
for prio, jobid in jobsToUncache:
self.cachedJobs[prio].pop(jobid)
self.cachedJobIDs.remove(jobid)
logging.info("Site submission report: %s", dict(jobSubmitLogBySites))
logging.info("Priority submission report: %s",
dict(jobSubmitLogByPriority))
logging.info("Have %s packages to submit.", len(jobsToSubmit))
logging.info("Have %s jobs to submit.", jobsCount)
logging.info("Done assigning site locations.")
return jobsToSubmit
def submitJobs(self, jobsToSubmit):
"""
_submitJobs_
Actually do the submission of the jobs
"""
jobList = []
idList = []
if len(jobsToSubmit) == 0:
logging.debug("There are no packages to submit.")
return
for package in jobsToSubmit.keys():
sandbox = self.sandboxPackage[package]
jobs = jobsToSubmit.get(package, [])
for job in jobs:
job['location'], job['plugin'], job[
'site_cms_name'] = self.getSiteInfo(
job['custom']['location'])
job['sandbox'] = sandbox
idList.append({
'jobid': job['id'],
'location': job['custom']['location']
})
#Clean out the package reference
del self.sandboxPackage[package]
jobList.extend(jobs)
myThread = threading.currentThread()
myThread.transaction.begin()
# Run the actual underlying submit code using bossAir
successList, failList = self.bossAir.submit(jobs=jobList)
logging.info("Jobs that succeeded/failed submission: %d/%d.",
len(successList), len(failList))
# Propagate states in the WMBS database
logging.debug("Propagating success state to WMBS.")
self.changeState.propagate(successList, 'executing', 'created')
logging.debug("Propagating fail state to WMBS.")
self.changeState.propagate(failList, 'submitfailed', 'created')
# At the end we mark the locations of the jobs
# This applies even to failed jobs, since the location
# could be part of the failure reason.
logging.debug("Updating job location...")
self.setLocationAction.execute(bulkList=idList,
conn=myThread.transaction.conn,
transaction=True)
myThread.transaction.commit()
logging.info("Transaction cycle successfully completed.")
return
def getSiteInfo(self, jobSite):
"""
_getSiteInfo_
This is how you get the name of a CE and the plugin for a job
"""
if not jobSite in self.locationDict.keys():
siteInfo = self.locationAction.execute(siteName=jobSite)
self.locationDict[jobSite] = siteInfo[0]
return (self.locationDict[jobSite].get('ce_name'),
self.locationDict[jobSite].get('plugin'),
self.locationDict[jobSite].get('cms_name'))
@timeFunction
def algorithm(self, parameters=None):
"""
_algorithm_
Try to, in order:
1) Refresh the cache
2) Find jobs for all the necessary sites
3) Submit the jobs to the plugin
"""
myThread = threading.currentThread()
if self.useReqMgrForCompletionCheck:
# only runs when reqmgr is used (not Tier0)
self.removeAbortedForceCompletedWorkflowFromCache()
agentConfig = self.reqAuxDB.getWMAgentConfig(
self.config.Agent.hostName)
self.condorFraction = agentConfig.get('CondorJobsFraction', 0.75)
self.condorOverflowFraction = agentConfig.get(
"CondorOverflowFraction", 0.2)
else:
# For Tier0 agent
self.condorFraction = 1
self.condorOverflowFraction = 0
if not self.passSubmitConditions():
msg = "JobSubmitter didn't pass the submit conditions. Skipping this cycle."
logging.warning(msg)
myThread.logdbClient.post("JobSubmitter_submitWork", msg,
"warning")
return
try:
myThread.logdbClient.delete("JobSubmitter_submitWork",
"warning",
this_thread=True)
self.getThresholds()
self.refreshCache()
jobsToSubmit = self.assignJobLocations()
self.submitJobs(jobsToSubmit=jobsToSubmit)
except WMException:
if getattr(myThread, 'transaction', None) != None:
myThread.transaction.rollback()
raise
except Exception as ex:
msg = 'Fatal error in JobSubmitter:\n'
msg += str(ex)
#msg += str(traceback.format_exc())
msg += '\n\n'
logging.error(msg)
if getattr(myThread, 'transaction', None) != None:
myThread.transaction.rollback()
raise JobSubmitterPollerException(msg)
return
def passSubmitConditions(self):
"""
_passSubmitConditions_
Check whether the component is allowed to submit jobs to condor.
Initially it has only one condition, which is the total number of
jobs we can have in condor (pending + running) per schedd, set by
MAX_JOBS_PER_OWNER.
"""
myThread = threading.currentThread()
freeSubmitSlots = availableScheddSlots(
dbi=myThread.dbi,
logger=logging,
condorFraction=self.condorFraction)
self.maxJobsThisCycle = min(freeSubmitSlots, self.maxJobsPerPoll)
return (self.maxJobsThisCycle > 0)
def terminate(self, params):
"""
_terminate_
Kill the code after one final pass when called by the master thread.
"""
logging.debug("terminating. doing one more pass before we die")
self.algorithm(params)
class MSCore(object):
"""
This class provides core functionality for
MSTransferor, MSMonitor and MSOutput classes.
"""
def __init__(self, msConfig, logger=None):
"""
Provides setup for MSTransferor and MSMonitor classes
:param config: MS service configuration
:param logger: logger object (optional)
"""
self.logger = getMSLogger(getattr(msConfig, 'verbose', False), logger)
self.msConfig = msConfig
self.logger.info("Configuration including default values:\n%s",
self.msConfig)
self.reqmgr2 = ReqMgr(self.msConfig['reqmgr2Url'], logger=self.logger)
self.reqmgrAux = ReqMgrAux(self.msConfig['reqmgr2Url'],
httpDict={'cacheduration': 1.0},
logger=self.logger)
# hard code it to production DBS otherwise PhEDEx subscribe API fails to match TMDB data
dbsUrl = "https://cmsweb.cern.ch/dbs/prod/global/DBSReader"
if usingRucio():
# FIXME: we cannot use Rucio in write mode yet
# self.rucio = Rucio(self.msConfig['rucioAccount'], configDict={"logger": self.logger})
self.phedex = PhEDEx(httpDict={'cacheduration': 0.5},
dbsUrl=dbsUrl,
logger=self.logger)
else:
self.phedex = PhEDEx(httpDict={'cacheduration': 0.5},
dbsUrl=dbsUrl,
logger=self.logger)
def unifiedConfig(self):
"""
Fetches the unified configuration
:return: unified configuration content
"""
res = self.reqmgrAux.getUnifiedConfig(docName="config")
if res:
if isinstance(res, list):
return res[0]
return res
else:
return {}
def change(self, reqName, reqStatus, prefix='###'):
"""
Update the request status in ReqMgr2
"""
try:
if self.msConfig['enableStatusTransition']:
self.logger.info('%s updating %s status to: %s', prefix,
reqName, reqStatus)
self.reqmgr2.updateRequestStatus(reqName, reqStatus)
else:
self.logger.info('DRY-RUN:: %s updating %s status to: %s',
prefix, reqName, reqStatus)
except Exception as err:
self.logger.exception("Failed to change request status. Error: %s",
str(err))
def updateReportDict(self, reportDict, keyName, value):
"""
Provided a key name and value, validate the key name
and update the report dictionary if it passes the validation
:param reportDict: dictionary with a summary of the service
:param keyName: string with the key name in the report
:param value: string/integer value with the content of a metric
:return: the updated dictionary
"""
if keyName not in reportDict:
self.logger.error("Report metric '%s' is not supported", keyName)
else:
reportDict[keyName] = value
return reportDict
class ErrorHandlerPoller(BaseWorkerThread):
"""
Polls for Error Conditions, handles them
"""
def __init__(self, config):
"""
Initialise class members
"""
BaseWorkerThread.__init__(self)
self.config = config
myThread = threading.currentThread()
self.daoFactory = DAOFactory(package="WMCore.WMBS",
logger=myThread.logger,
dbinterface=myThread.dbi)
self.changeState = ChangeState(self.config)
self.maxRetries = self.config.ErrorHandler.maxRetries
if not isinstance(self.maxRetries, dict):
self.maxRetries = {'default': self.maxRetries}
if 'default' not in self.maxRetries:
raise ErrorHandlerException(
'Max retries for the default job type must be specified')
self.exitCodesNoRetry = []
self.maxProcessSize = getattr(self.config.ErrorHandler,
'maxProcessSize', 250)
self.maxFailTime = getattr(self.config.ErrorHandler, 'maxFailTime',
32 * 3600)
self.readFWJR = getattr(self.config.ErrorHandler, 'readFWJR', False)
self.passCodes = getattr(self.config.ErrorHandler, 'passExitCodes', [])
self.getJobs = self.daoFactory(classname="Jobs.GetAllJobs")
self.idLoad = self.daoFactory(classname="Jobs.LoadFromIDWithType")
self.loadAction = self.daoFactory(classname="Jobs.LoadForErrorHandler")
self.dataCollection = DataCollectionService(
url=config.ACDC.couchurl, database=config.ACDC.database)
if hasattr(self.config, "Tier0Feeder"):
self.reqAuxDB = None
else:
self.reqAuxDB = ReqMgrAux(self.config.General.ReqMgr2ServiceURL)
return
def setup(self, parameters=None):
"""
Load DB objects required for queries
"""
# For now, does nothing
return
def terminate(self, params):
"""
_terminate_
Do one pass, then commit suicide
"""
logging.debug("terminating. doing one more pass before we die")
self.algorithm(params)
def exhaustJobs(self, jobList):
"""
_exhaustJobs_
Actually do the jobs exhaustion
"""
self.changeState.propagate(jobList, 'exhausted', 'retrydone')
# Remove all the files in the exhausted jobs.
logging.debug("About to fail input files for exhausted jobs")
for job in jobList:
job.failInputFiles()
# Do not build ACDC for utilitarian job types
jobList = [
job for job in jobList
if job['type'] not in ['LogCollect', 'Cleanup']
]
self.handleACDC(jobList)
return
def processRetries(self, jobList, state):
"""
_processRetries_
Actually do the retries
"""
logging.info("Processing retries for %d failed jobs of type %sfailed",
len(jobList), state)
retrydoneJobs = []
cooloffJobs = []
passJobs = []
# Retries < max retry count
for job in jobList:
allowedRetries = self.maxRetries.get(job['type'],
self.maxRetries['default'])
# Retries < allowed max retry count
if job['retry_count'] < allowedRetries and state != 'create':
cooloffJobs.append(job)
# Check if Retries >= allowed max retry count
elif job['retry_count'] >= allowedRetries or state == 'create':
retrydoneJobs.append(job)
msg = "Stopping retries for job %d" % job['id']
logging.debug(msg)
logging.debug("JobInfo: %s", job)
if self.readFWJR:
# Then we have to check each FWJR for exit status
cooloffJobs, passJobs, retrydoneFWJRJobs = self.readFWJRForErrors(
cooloffJobs)
retrydoneJobs.extend(retrydoneFWJRJobs)
# Now to actually do something.
logging.debug("About to propagate jobs")
if len(retrydoneJobs) > 0:
self.changeState.propagate(retrydoneJobs,
'retrydone',
'%sfailed' % state,
updatesummary=True)
if len(cooloffJobs) > 0:
self.changeState.propagate(cooloffJobs,
'%scooloff' % state,
'%sfailed' % state,
updatesummary=True)
if len(passJobs) > 0:
# Overwrite the transition states and move directly to created
self.changeState.propagate(passJobs, 'created', 'new')
return
def handleACDC(self, jobList):
"""
_handleACDC_
Do the ACDC creation and hope it works
"""
idList = [x['id'] for x in jobList]
logging.info("Starting to build ACDC with %i jobs", len(idList))
logging.info("This operation will take some time...")
loadList = self.loadJobsFromListFull(idList)
for job in loadList:
job.getMask()
self.dataCollection.failedJobs(loadList)
return
def readFWJRForErrors(self, jobList):
"""
_readFWJRForErrors_
Check the FWJRs of the failed jobs
and determine those that can be retried
and which must be retried without going through cooloff.
Returns a triplet with cooloff, passed and exhausted jobs.
"""
cooloffJobs = []
passJobs = []
exhaustJobs = []
if self.reqAuxDB:
self.exitCodesNoRetry = self.reqAuxDB.getWMAgentConfig(
self.config.Agent.hostName).get("NoRetryExitCodes", [])
for job in jobList:
report = Report()
reportPath = job['fwjr_path']
if reportPath is None:
logging.error(
"No FWJR in job %i, ErrorHandler can't process it.\n Passing it to cooloff.",
job['id'])
cooloffJobs.append(job)
continue
if not os.path.isfile(reportPath):
logging.error(
"Failed to find FWJR for job %i in location %s.\n Passing it to cooloff.",
job['id'], reportPath)
cooloffJobs.append(job)
continue
try:
report.load(reportPath)
# First let's check the time conditions
times = report.getFirstStartLastStop()
startTime = None
stopTime = None
if times is not None:
startTime = times['startTime']
stopTime = times['stopTime']
# correct the location if the original location is different from recorded in wmbs
# WARNING: we are not updating job location in wmbs only updating in couchdb by doing this.
# If location in wmbs needs to be updated, it should happen in JobAccountant.
locationFromFWJR = report.getSiteName()
if locationFromFWJR:
job["location"] = locationFromFWJR
job["site_cms_name"] = locationFromFWJR
if startTime is None or stopTime is None:
# We have no information to make a decision, keep going.
logging.debug("No start, stop times for steps for job %i",
job['id'])
elif stopTime - startTime > self.maxFailTime:
msg = "Job %i exhausted after running on node for %i seconds" % (
job['id'], stopTime - startTime)
logging.debug(msg)
exhaustJobs.append(job)
continue
if len([
x for x in report.getExitCodes()
if x in self.exitCodesNoRetry
]):
msg = "Job %i exhausted due to a bad exit code (%s)" % (
job['id'], str(report.getExitCodes()))
logging.error(msg)
exhaustJobs.append(job)
continue
if len(
[x for x in report.getExitCodes() if x in self.passCodes]):
msg = "Job %i restarted immediately due to an exit code (%s)" % (
job['id'], str(report.getExitCodes()))
logging.debug(msg)
passJobs.append(job)
continue
cooloffJobs.append(job)
except Exception as ex:
logging.warning(
"Exception while trying to check jobs for failures!")
logging.warning(str(ex))
logging.warning("Ignoring and sending job to cooloff")
cooloffJobs.append(job)
return cooloffJobs, passJobs, exhaustJobs
def handleRetryDoneJobs(self, jobList):
"""
_handleRetryDoneJobs_
"""
myThread = threading.currentThread()
logging.info("About to process %d retry done jobs", len(jobList))
myThread.transaction.begin()
self.exhaustJobs(jobList)
myThread.transaction.commit()
return
def handleFailedJobs(self, jobList, state):
"""
_handleFailedJobs_
"""
myThread = threading.currentThread()
logging.info("About to process %d failures", len(jobList))
myThread.transaction.begin()
self.processRetries(jobList, state)
myThread.transaction.commit()
return
def handleErrors(self):
"""
Queries DB for all watched filesets, if matching filesets become
available, create the subscriptions
"""
# Run over created, submitted and executed job failures
failure_states = ['create', 'submit', 'job']
for state in failure_states:
idList = self.getJobs.execute(state="%sfailed" % state)
logging.info("Found %d failed jobs in state %sfailed", len(idList),
state)
while len(idList) > 0:
tmpList = idList[:self.maxProcessSize]
idList = idList[self.maxProcessSize:]
jobList = self.loadJobsFromList(tmpList)
self.handleFailedJobs(jobList, state)
# Run over jobs done with retries
idList = self.getJobs.execute(state='retrydone')
logging.info("Found %d jobs done with all retries", len(idList))
while len(idList) > 0:
tmpList = idList[:self.maxProcessSize]
idList = idList[self.maxProcessSize:]
jobList = self.loadJobsFromList(tmpList)
self.handleRetryDoneJobs(jobList)
return
def loadJobsFromList(self, idList):
"""
_loadJobsFromList_
Load jobs in bulk
"""
binds = []
for jobID in idList:
binds.append({"jobid": jobID})
results = self.idLoad.execute(jobID=binds)
# You have to have a list
if isinstance(results, dict):
results = [results]
listOfJobs = []
for entry in results:
# One job per entry
tmpJob = Job(id=entry['id'])
tmpJob.update(entry)
listOfJobs.append(tmpJob)
return listOfJobs
def loadJobsFromListFull(self, idList):
"""
_loadJobsFromList_
Load jobs in bulk.
Include the full metadata.
"""
binds = []
for jobID in idList:
binds.append({"jobid": jobID})
results = self.loadAction.execute(jobID=binds)
# You have to have a list
if isinstance(results, dict):
results = [results]
listOfJobs = []
for entry in results:
# One job per entry
tmpJob = Job(id=entry['id'])
tmpJob.update(entry)
listOfJobs.append(tmpJob)
return listOfJobs
@timeFunction
def algorithm(self, parameters=None):
"""
Performs the handleErrors method, looking for each type of failure
And deal with it as desired.
"""
logging.debug("Running error handling algorithm")
try:
myThread = threading.currentThread()
self.handleErrors()
except (CouchConnectionError, HTTPException) as ex:
if getattr(myThread, 'transaction', None) is not None:
myThread.transaction.rollback()
msg = "Caught CouchConnectionError/HTTPException exception in ErrorHandler. "
msg += "Transactions postponed until the next polling cycle\n"
msg += str(ex)
logging.error(msg)
except Exception as ex:
if getattr(myThread, 'transaction', None) is not None:
myThread.transaction.rollback()
msg = "Caught unexpected exception in ErrorHandler:\n"
msg += str(ex)
logging.exception(msg)
raise ErrorHandlerException(msg)
class BuildParentLock(CherryPyPeriodicTask):
def __init__(self, rest, config):
super(BuildParentLock, self).__init__(config)
self.reqmgrAux = ReqMgrAux(config.reqmgr2_url, logger=self.logger)
self.dbs = DBS3Reader(config.dbs_url)
# cache of dbs lookups mapping input dataset to parent dataset
self.dbsLookupCache = {}
# set of of currently active datasets requiring parent dataset
self.inputDatasetCache = set()
self.reqDB = RequestDBReader(config.reqmgrdb_url)
self.filterKeys = [
'assignment-approved', 'assigned', 'staging', 'staged', 'failed',
'acquired', 'running-open', 'running-closed', 'force-complete',
'completed', 'closed-out'
]
def setConcurrentTasks(self, config):
"""
sets the list of functions which
"""
self.concurrentTasks = [{
'func': self.fetchIncludeParentsRequests,
'duration': config.updateParentsInterval
}]
def fetchIncludeParentsRequests(self, config):
"""
Fetch active requests from the "requestsincludeparents" couch view that
have IncludeParents=True, find parents of each dataset and send to
reqmgr2 auxiliary database.
"""
# use this boolean to signal whether there were datasets that failed
# to get their parentage resolved
incompleteParentage = False
# use this boolean to signal if new parent datasets need to be locked
auxDbUpdateRequired = False
setDsets = set()
setParents = set()
dictParents = {}
self.logger.info("Executing parent lock cherrypy thread")
# query couch view to find datasets for workflows requiring parent datasets
# only returning requests with the statuses in filterKeys
try:
results = self.reqDB._getCouchView("requestsincludeparents", {},
self.filterKeys)
except Exception as ex:
self.logger.error(
"Error retrieving requests including parent datasets from couchdb."
)
self.logger.error("Error: %s", str(ex))
return
for row in results["rows"]:
dataset = row["value"]
setDsets.add(dataset)
# check to see if any changes have been made
if setDsets != self.inputDatasetCache:
auxDbUpdateRequired = True
self.inputDatasetCache = setDsets.copy()
self.logger.info(
"Found %d unique datasets requiring the parent dataset",
len(setDsets))
if auxDbUpdateRequired:
self.logger.info("Found new parent dataset locks to update.")
# look up parent datasets first via the local DBS cache, if not found do lookup via DBS
for dset in setDsets:
if dset in self.dbsLookupCache:
setParents.add(self.dbsLookupCache[dset])
self.logger.info(
"Resolved parentage via lookup cache for: %s", dset)
else:
try:
res = self.dbs.listDatasetParents(dset)
except Exception as exc:
self.logger.warning(
"Failed to resolve parentage for: %s. Error: %s",
dset, str(exc))
incompleteParentage = True
continue
self.logger.info("Resolved parentage via DBS for: %s", res)
if res:
setParents.add(res[0]['parent_dataset'])
self.dbsLookupCache[dset] = res[0]['parent_dataset']
if not incompleteParentage:
dictParents['parentlocks'] = list(setParents)
if self.reqmgrAux.updateParentLocks(dictParents):
self.logger.info(
"Parentage lookup complete and auxiliary database updated."
)
else:
self.logger.info(
"Error updating parentage document. Using stale data until next cycle."
)
else:
# then don't replace any data for the moment, simply add new parents
previousData = self.reqmgrAux.getParentLocks()
# check to see if response from aux db has been populated
if previousData and 'parentlocks' in previousData[0]:
setPreviousData = set(previousData[0]['parentlocks'])
setParents = setParents | setPreviousData
dictParents['parentlocks'] = list(setParents)
self.reqmgrAux.updateParentLocks(dictParents)
self.logger.info(
"Parentage lookup complete (with errors) and auxiliary database updated."
)
else:
self.logger.info(
"Parent locks not returned from auxiliary database. Skipping parentage update."
)
else:
self.logger.info(
"No new parent datasets need locked. Skipping update of auxiliary database."
)
return