def doMaster(self):
siteNames = getSites()
if not siteNames['OK']:
return siteNames
siteNames = siteNames['Value']
ces = CSHelpers.getComputingElements()
if not ces['OK']:
return ces
ces = ces['Value']
for site in siteNames:
# 2 hours of window
result = self.doNew((site, None, 1))
if not result['OK']:
self.metrics['failed'].append(result)
for ce in ces:
# 2 hours of window
result = self.doNew((None, ce, 1))
if not result['OK']:
self.metrics['failed'].append(result)
return S_OK(self.metrics)
def export_getComputingElements(self):
"""
Returns the list of all CEs.
"""
gLogger.info('getComputingElements')
return CSHelpers.getComputingElements()
def doMaster(self):
'''
Master method, which looks little bit spaguetti code, sorry !
- It gets all sites and transforms them into gocSites.
- It gets all the storage elements and transforms them into their hosts
- It gets the fts, the ces and file catalogs.
'''
gocSites = CSHelpers.getGOCSites()
if not gocSites['OK']:
return gocSites
gocSites = gocSites['Value']
sesHosts = CSHelpers.getStorageElementsHosts()
if not sesHosts['OK']:
return sesHosts
sesHosts = sesHosts['Value']
resources = sesHosts
#
#
#FIXME: file catalogs need also to use their hosts
# something similar applies to FTS Channels
#
#fts = CSHelpers.getFTS()
#if fts[ 'OK' ]:
# resources = resources + fts[ 'Value' ]
#fc = CSHelpers.getFileCatalogs()
#if fc[ 'OK' ]:
# resources = resources + fc[ 'Value' ]
ce = CSHelpers.getComputingElements()
if ce['OK']:
resources = resources + ce['Value']
gLogger.verbose('Processing Sites: %s' % ', '.join(gocSites))
siteRes = self.doNew(('Site', gocSites))
if not siteRes['OK']:
self.metrics['failed'].append(siteRes['Message'])
gLogger.verbose('Processing Resources: %s' % ', '.join(resources))
resourceRes = self.doNew(('Resource', resources))
if not resourceRes['OK']:
self.metrics['failed'].append(resourceRes['Message'])
return S_OK(self.metrics)
################################################################################
#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF
def doMaster( self ):
'''
Master method, which looks little bit spaguetti code, sorry !
- It gets all sites and transforms them into gocSites.
- It gets all the storage elements and transforms them into their hosts
- It gets the fts, the ces and file catalogs.
'''
gocSites = CSHelpers.getGOCSites()
if not gocSites[ 'OK' ]:
return gocSites
gocSites = gocSites[ 'Value' ]
sesHosts = CSHelpers.getStorageElementsHosts()
if not sesHosts[ 'OK' ]:
return sesHosts
sesHosts = sesHosts[ 'Value' ]
resources = sesHosts
#
#
#FIXME: file catalogs need also to use their hosts
# something similar applies to FTS Channels
#
#fts = CSHelpers.getFTS()
#if fts[ 'OK' ]:
# resources = resources + fts[ 'Value' ]
#fc = CSHelpers.getFileCatalogs()
#if fc[ 'OK' ]:
# resources = resources + fc[ 'Value' ]
ce = CSHelpers.getComputingElements()
if ce[ 'OK' ]:
resources = resources + ce[ 'Value' ]
gLogger.info( 'Processing Sites: %s' % ', '.join( gocSites ) )
siteRes = self.doNew( ( 'Site', gocSites ) )
if not siteRes[ 'OK' ]:
self.metrics[ 'failed' ].append( siteRes[ 'Message' ] )
gLogger.info( 'Processing Resources: %s' % ', '.join( resources ) )
resourceRes = self.doNew( ( 'Resource', resources ) )
if not resourceRes[ 'OK' ]:
self.metrics[ 'failed' ].append( resourceRes[ 'Message' ] )
return S_OK( self.metrics )
################################################################################
#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF
def doMaster( self ):
''' Master method, which looks little bit spaghetti code, sorry !
- It gets all sites and transforms them into gocSites.
- It gets all the storage elements and transforms them into their hosts
- It gets the the CEs (FTS and file catalogs will come).
'''
gocSites = CSHelpers.getGOCSites()
if not gocSites[ 'OK' ]:
return gocSites
gocSites = gocSites[ 'Value' ]
sesHosts = CSHelpers.getStorageElementsHosts()
if not sesHosts[ 'OK' ]:
return sesHosts
sesHosts = sesHosts[ 'Value' ]
resources = sesHosts
ftsServer = getFTS3Servers()
if ftsServer[ 'OK' ]:
resources.extend( ftsServer[ 'Value' ] )
#TODO: file catalogs need also to use their hosts
#fc = CSHelpers.getFileCatalogs()
#if fc[ 'OK' ]:
# resources = resources + fc[ 'Value' ]
ce = CSHelpers.getComputingElements()
if ce[ 'OK' ]:
resources.extend( ce[ 'Value' ] )
gLogger.verbose( 'Processing Sites: %s' % ', '.join( gocSites ) )
siteRes = self.doNew( ( 'Site', gocSites ) )
if not siteRes[ 'OK' ]:
self.metrics[ 'failed' ].append( siteRes[ 'Message' ] )
gLogger.verbose( 'Processing Resources: %s' % ', '.join( resources ) )
resourceRes = self.doNew( ( 'Resource', resources ) )
if not resourceRes[ 'OK' ]:
self.metrics[ 'failed' ].append( resourceRes[ 'Message' ] )
return S_OK( self.metrics )
################################################################################
#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF
def doMaster(self):
"""
Master method, which looks little bit spaguetti code, sorry !
- It gets all sites and transforms them into gocSites.
- It gets all the storage elements and transforms them into their hosts
- It gets the fts, the ces and file catalogs.
"""
gocSites = CSHelpers.getGOCSites()
if not gocSites["OK"]:
return gocSites
gocSites = gocSites["Value"]
sesHosts = CSHelpers.getStorageElementsHosts()
if not sesHosts["OK"]:
return sesHosts
sesHosts = sesHosts["Value"]
resources = sesHosts
#
#
# FIXME: file catalogs need also to use their hosts
# something similar applies to FTS Channels
#
# fts = CSHelpers.getFTS()
# if fts[ 'OK' ]:
# resources = resources + fts[ 'Value' ]
# fc = CSHelpers.getFileCatalogs()
# if fc[ 'OK' ]:
# resources = resources + fc[ 'Value' ]
ce = CSHelpers.getComputingElements()
if ce["OK"]:
resources = resources + ce["Value"]
gLogger.verbose("Processing Sites: %s" % ", ".join(gocSites))
siteRes = self.doNew(("Site", gocSites))
if not siteRes["OK"]:
self.metrics["failed"].append(siteRes["Message"])
gLogger.verbose("Processing Resources: %s" % ", ".join(resources))
resourceRes = self.doNew(("Resource", resources))
if not resourceRes["OK"]:
self.metrics["failed"].append(resourceRes["Message"])
return S_OK(self.metrics)
def doMaster( self ):
''' Master method, which looks little bit spaghetti code, sorry !
- It gets all sites and transforms them into gocSites.
- It gets all the storage elements and transforms them into their hosts
- It gets the the CEs (FTS and file catalogs will come).
'''
gocSites = CSHelpers.getGOCSites()
if not gocSites[ 'OK' ]:
return gocSites
gocSites = gocSites[ 'Value' ]
sesHosts = CSHelpers.getStorageElementsHosts()
if not sesHosts[ 'OK' ]:
return sesHosts
sesHosts = sesHosts[ 'Value' ]
resources = sesHosts
ftsServer = getFTS3Servers()
if ftsServer[ 'OK' ]:
resources.extend( ftsServer[ 'Value' ] )
#TODO: file catalogs need also to use their hosts
#fc = CSHelpers.getFileCatalogs()
#if fc[ 'OK' ]:
# resources = resources + fc[ 'Value' ]
ce = CSHelpers.getComputingElements()
if ce[ 'OK' ]:
resources.extend( ce[ 'Value' ] )
self.log.verbose( 'Processing Sites: %s' % ', '.join( gocSites ) )
siteRes = self.doNew( ( 'Site', gocSites ) )
if not siteRes[ 'OK' ]:
self.metrics[ 'failed' ].append( siteRes[ 'Message' ] )
self.log.verbose( 'Processing Resources: %s' % ', '.join( resources ) )
resourceRes = self.doNew( ( 'Resource', resources ) )
if not resourceRes[ 'OK' ]:
self.metrics[ 'failed' ].append( resourceRes[ 'Message' ] )
return S_OK( self.metrics )
def doMaster(self):
""" Master method, which looks little bit spaghetti code, sorry !
- It gets all sites and transforms them into gocSites.
- It gets all the storage elements and transforms them into their hosts
- It gets the the CEs (FTS and file catalogs will come).
"""
gocSites = CSHelpers.getGOCSites()
if not gocSites["OK"]:
return gocSites
gocSites = gocSites["Value"]
sesHosts = CSHelpers.getStorageElementsHosts()
if not sesHosts["OK"]:
return sesHosts
sesHosts = sesHosts["Value"]
resources = sesHosts
ftsServer = getFTS3Servers()
if ftsServer["OK"]:
resources.extend(ftsServer["Value"])
# TODO: file catalogs need also to use their hosts
# fc = CSHelpers.getFileCatalogs()
# if fc[ 'OK' ]:
# resources = resources + fc[ 'Value' ]
ce = CSHelpers.getComputingElements()
if ce["OK"]:
resources.extend(ce["Value"])
self.log.verbose("Processing Sites: %s" % ", ".join(gocSites))
siteRes = self.doNew(("Site", gocSites))
if not siteRes["OK"]:
self.metrics["failed"].append(siteRes["Message"])
self.log.verbose("Processing Resources: %s" % ", ".join(resources))
resourceRes = self.doNew(("Resource", resources))
if not resourceRes["OK"]:
self.metrics["failed"].append(resourceRes["Message"])
return S_OK(self.metrics)
def __removeNonExistingResourcesFromRM(self):
'''
Remove resources from DowntimeCache table that no longer exist in the CS.
'''
if not getServiceURL("ResourceStatus/ResourceManagement"):
gLogger.verbose(
'ResourceManagement is not installed, skipping removal of non existing resources...'
)
return S_OK()
sesHosts = getStorageElementsHosts()
if not sesHosts['OK']:
return sesHosts
sesHosts = sesHosts['Value']
resources = sesHosts
ftsServer = getFTS3Servers(hostOnly=True)
if ftsServer['OK']:
resources.extend(ftsServer['Value'])
ce = CSHelpers.getComputingElements()
if ce['OK']:
resources.extend(ce['Value'])
downtimes = self.rManagement.selectDowntimeCache()
if not downtimes['OK']:
return downtimes
# Remove hosts that no longer exist in the CS
for host in downtimes['Value']:
gLogger.verbose('Checking if %s is still in the CS' % host[0])
if host[0] not in resources:
gLogger.verbose('%s is no longer in CS, removing entry...' %
host[0])
result = self.rManagement.deleteDowntimeCache(name=host[0])
if not result['OK']:
return result
return S_OK()
def __removeNonExistingResourcesFromRM(self):
'''
Remove resources from DowntimeCache table that no longer exist in the CS.
'''
if not getServiceURL("ResourceStatus/ResourceManagement"):
gLogger.verbose(
'ResourceManagement is not installed, skipping removal of non existing resources...')
return S_OK()
sesHosts = CSHelpers.getStorageElementsHosts()
if not sesHosts['OK']:
return sesHosts
sesHosts = sesHosts['Value']
resources = sesHosts
ftsServer = getFTS3Servers()
if ftsServer['OK']:
resources.extend(ftsServer['Value'])
ce = CSHelpers.getComputingElements()
if ce['OK']:
resources.extend(ce['Value'])
downtimes = self.rManagement.selectDowntimeCache()
if not downtimes['OK']:
return downtimes
# Remove hosts that no longer exist in the CS
for host in downtimes['Value']:
gLogger.verbose('Checking if %s is still in the CS' % host[0])
if host[0] not in resources:
gLogger.verbose(
'%s is no longer in CS, removing entry...' % host[0])
result = self.rManagement.deleteDowntimeCache(name=host[0])
if not result['OK']:
return result
return S_OK()
def doMaster(self):
siteNames = getSites()
if not siteNames['OK']:
return siteNames
siteNames = siteNames['Value']
ces = CSHelpers.getComputingElements()
if not ces['OK']:
return ces
ces = ces['Value']
pilotResults = self.doNew(('Site', siteNames))
if not pilotResults['OK']:
self.metrics['failed'].append(pilotResults['Message'])
pilotResults = self.doNew(('Resource', ces))
if not pilotResults['OK']:
self.metrics['failed'].append(pilotResults['Message'])
return S_OK(self.metrics)
def doMaster( self ):
siteNames = CSHelpers.getSites()
if not siteNames[ 'OK' ]:
return siteNames
siteNames = siteNames[ 'Value' ]
ces = CSHelpers.getComputingElements()
if not ces[ 'OK' ]:
return ces
ces = ces[ 'Value' ]
pilotResults = self.doNew( ( 'Site', siteNames ) )
if not pilotResults[ 'OK' ]:
self.metrics[ 'failed' ].append( pilotResults[ 'Message' ] )
pilotResults = self.doNew( ( 'Resource', ces ) )
if not pilotResults[ 'OK' ]:
self.metrics[ 'failed' ].append( pilotResults[ 'Message' ] )
return S_OK( self.metrics )
def __syncComputingElements(self):
'''
Sync CEs: compares CS with DB and does the necessary modifications.
'''
cesCS = CSHelpers.getComputingElements()
if not cesCS['OK']:
return cesCS
cesCS = cesCS['Value']
gLogger.verbose('%s Computing elements found in CS' % len(cesCS))
cesDB = self.rStatus.selectStatusElement('Resource',
'Status',
elementType='CE',
meta={'columns': ['name']})
if not cesDB['OK']:
return cesDB
cesDB = [ceDB[0] for ceDB in cesDB['Value']]
# ComputingElements that are in DB but not in CS
toBeDeleted = list(set(cesDB).difference(set(cesCS)))
gLogger.verbose('%s Computing elements to be deleted' %
len(toBeDeleted))
# Delete storage elements
for ceName in toBeDeleted:
deleteQuery = self.rStatus._extermineStatusElement(
'Resource', ceName)
gLogger.verbose('... %s' % ceName)
if not deleteQuery['OK']:
return deleteQuery
#statusTypes = RssConfiguration.getValidStatusTypes()[ 'Resource' ]
statusTypes = self.rssConfig.getConfigStatusType('CE')
cesTuple = self.rStatus.selectStatusElement(
'Resource',
'Status',
elementType='CE',
meta={'columns': ['name', 'statusType']})
if not cesTuple['OK']:
return cesTuple
cesTuple = cesTuple['Value']
# For each ( se, statusType ) tuple not present in the DB, add it.
cesStatusTuples = [(se, statusType) for se in cesCS
for statusType in statusTypes]
toBeAdded = list(set(cesStatusTuples).difference(set(cesTuple)))
gLogger.debug('%s Computing elements entries to be added' %
len(toBeAdded))
for ceTuple in toBeAdded:
_name = ceTuple[0]
_statusType = ceTuple[1]
_status = 'Unknown'
_reason = 'Synchronized'
_elementType = 'CE'
query = self.rStatus.addIfNotThereStatusElement(
'Resource',
'Status',
name=_name,
statusType=_statusType,
status=_status,
elementType=_elementType,
reason=_reason)
if not query['OK']:
return query
return S_OK()
def doCommand(self):
"""
Returns failed pilots using the DIRAC accounting system for every CE
for the last self.args[0] hours
:params:
:attr:`CEs`: list of CEs (when not given, take every CE)
:returns:
"""
if 'hours' not in self.args:
return S_ERROR('Number of hours not specified')
hours = self.args['hours']
ces = None
if 'ces' in self.args:
ces = self.args['ces']
if ces is None:
# FIXME: pointing to the CSHelper instead
# meta = {'columns':'ResourceName'}
# CEs = self.rsClient.getResource( resourceType = [ 'CE','CREAMCE' ], meta = meta )
# if not CEs['OK']:
# return CEs
# CEs = [ ce[0] for ce in CEs['Value'] ]
ces = CSHelpers.getComputingElements()
if not ces['OK']:
return ces
ces = ces['Value']
if not ces:
return S_ERROR('CEs is empty')
fromD = datetime.utcnow() - timedelta(hours=hours)
toD = datetime.utcnow()
failedPilots = self.rClient.getReport('Pilot', 'NumberOfPilots', fromD, toD,
{'GridStatus': ['Aborted'],
'GridCE': ces
}, 'GridCE')
if not failedPilots['OK']:
return failedPilots
failedPilots = failedPilots['Value']
if 'data' not in failedPilots:
return S_ERROR('Missing data key')
if 'granularity' not in failedPilots:
return S_ERROR('Missing granularity key')
singlePlots = {}
for ce, value in failedPilots['data'].items():
if ce in ces:
plot = {}
plot['data'] = {ce: value}
plot['granularity'] = failedPilots['granularity']
singlePlots[ce] = plot
return S_OK(singlePlots)
def __syncComputingElements(self):
'''
Sync ComputingElements: compares CS with DB and does the necessary modifications.
'''
cesCS = CSHelpers.getComputingElements()
if not cesCS['OK']:
return cesCS
cesCS = cesCS['Value']
gLogger.verbose('%s Computing elements found in CS' % len(cesCS))
cesDB = self.rStatus.selectStatusElement('Resource', 'Status',
elementType='ComputingElement',
meta={'columns': ['Name']})
if not cesDB['OK']:
return cesDB
cesDB = [ceDB[0] for ceDB in cesDB['Value']]
# ComputingElements that are in DB but not in CS
toBeDeleted = list(set(cesDB).difference(set(cesCS)))
gLogger.verbose('%s Computing elements to be deleted' %
len(toBeDeleted))
# Delete storage elements
for ceName in toBeDeleted:
deleteQuery = self.rStatus._extermineStatusElement(
'Resource', ceName)
gLogger.verbose('... %s' % ceName)
if not deleteQuery['OK']:
return deleteQuery
#statusTypes = RssConfiguration.getValidStatusTypes()[ 'Resource' ]
statusTypes = self.rssConfig.getConfigStatusType('ComputingElement')
result = self.rStatus.selectStatusElement('Resource', 'Status',
elementType='ComputingElement',
meta={'columns': ['Name', 'StatusType']})
if not result['OK']:
return result
cesTuple = [(x[0], x[1]) for x in result['Value']]
# For each ( se, statusType ) tuple not present in the DB, add it.
cesStatusTuples = [(se, statusType)
for se in cesCS for statusType in statusTypes]
toBeAdded = list(set(cesStatusTuples).difference(set(cesTuple)))
gLogger.debug('%s Computing elements entries to be added' %
len(toBeAdded))
for ceTuple in toBeAdded:
_name = ceTuple[0]
_statusType = ceTuple[1]
_status = self.defaultStatus
_reason = 'Synchronized'
_elementType = 'ComputingElement'
query = self.rStatus.addIfNotThereStatusElement('Resource', 'Status', name=_name,
statusType=_statusType,
status=_status,
elementType=_elementType,
tokenOwner=self.tokenOwner,
reason=_reason)
if not query['OK']:
return query
return S_OK()
def __syncComputingElements(self):
"""
Sync CEs: compares CS with DB and does the necessary modifications.
"""
cesCS = CSHelpers.getComputingElements()
if not cesCS["OK"]:
return cesCS
cesCS = cesCS["Value"]
gLogger.verbose("%s Computing elements found in CS" % len(cesCS))
cesDB = self.rStatus.selectStatusElement("Resource", "Status", elementType="CE", meta={"columns": ["name"]})
if not cesDB["OK"]:
return cesDB
cesDB = [ceDB[0] for ceDB in cesDB["Value"]]
# ComputingElements that are in DB but not in CS
toBeDeleted = list(set(cesDB).difference(set(cesCS)))
gLogger.verbose("%s Computing elements to be deleted" % len(toBeDeleted))
# Delete storage elements
for ceName in toBeDeleted:
deleteQuery = self.rStatus._extermineStatusElement("Resource", ceName)
gLogger.verbose("... %s" % ceName)
if not deleteQuery["OK"]:
return deleteQuery
# statusTypes = RssConfiguration.getValidStatusTypes()[ 'Resource' ]
statusTypes = self.rssConfig.getConfigStatusType("CE")
cesTuple = self.rStatus.selectStatusElement(
"Resource", "Status", elementType="CE", meta={"columns": ["name", "statusType"]}
)
if not cesTuple["OK"]:
return cesTuple
cesTuple = cesTuple["Value"]
# For each ( se, statusType ) tuple not present in the DB, add it.
cesStatusTuples = [(se, statusType) for se in cesCS for statusType in statusTypes]
toBeAdded = list(set(cesStatusTuples).difference(set(cesTuple)))
gLogger.debug("%s Computing elements entries to be added" % len(toBeAdded))
for ceTuple in toBeAdded:
_name = ceTuple[0]
_statusType = ceTuple[1]
_status = "Unknown"
_reason = "Synchronized"
_elementType = "CE"
query = self.rStatus.addIfNotThereStatusElement(
"Resource",
"Status",
name=_name,
statusType=_statusType,
status=_status,
elementType=_elementType,
reason=_reason,
)
if not query["OK"]:
return query
return S_OK()
