def doCommand( self ):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getResourceStats`
:params:
:attr:`args`: a tuple
- `args[0]` string, a ValidRes. Should be in ('Site', 'Service')
- `args[1]` should be the name of the Site or Service
:returns:
"""
super( ResourceStats_Command, self ).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient( timeout = self.timeout )
try:
res = self.client.getResourceStats( self.args[0], self.args[1] )['Value']
except:
gLogger.exception( "Exception when calling ResourceStatusClient for %s %s" % ( self.args[0], self.args[1] ) )
return {'Result':'Unknown'}
return {'Result':res}
def __getSelectionData(self):
callback = {}
lhcbGroup = credentials.getSelectedGroup()
lhcbUser = str(credentials.getUsername())
RPC = getRPCClient("ResourceStatus/ResourceStatus")
client = ResourceStatusClient(serviceIn=RPC)
if len(request.params) > 0:
tmp = {}
for i in request.params:
tmp[i] = str(request.params[i])
callback["extra"] = tmp
####
result = client.getSitePresent(meta={'columns': 'SiteName'})
if result["OK"]:
sites = result["Value"]
try:
sites = list(sites)
except Exception, x:
gLogger.error("Exception during convertion to a list: %s" %
str(x))
sites = [] # Will return error on length check
tier1 = gConfig.getValue("/Website/PreferredSites",
[]) # Always return a list
if len(sites) > 0:
tier1.reverse()
tier1 = [[x] for x in tier1]
sites = [x for x in sites if x not in tier1
] # Removes sites which are in tier1 list
for i in tier1:
sites.insert(0, i)
sites.insert(0, ["All"])
else:
sites = [["Nothing to display"]]
def __changeSiteStatus( self, site, comment, statusType, status, printOutput = False ):
"""
Change the RSS status of the given site
"""
result = self.__checkSiteIsValid( site )
if not result['OK']:
return result
wmsAdmin = RPCClient( 'WorkloadManagement/WMSAdministrator' )
result = wmsAdmin.allowSite( site, comment )
if not result['OK']:
return result
rsc = ResourceStatusClient()
proxyInfo = getProxyInfo()
if not proxyInfo[ 'OK' ]:
return proxyInfo
userName = proxyInfo[ 'Value' ][ 'username' ]
tomorrow = datetime.utcnow().replace( microsecond = 0 ) + timedelta( days = 1 )
result = rsc.modifyStatusElement( 'Site', 'Status',
name = site,
statusType = statusType,
status = status,
reason = comment,
tokenOwner = userName,
tokenExpiration = tomorrow )
return result
def doCommand( self ):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getServiceStats`
:params:
:attr:`args`: a tuple
- args[1]: a ValidRes
- args[0]: should be the name of the Site
:returns:
{'Active':xx, 'Probing':yy, 'Banned':zz, 'Total':xyz}
"""
super( ServiceStats_Command, self ).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient( timeout = self.timeout )
try:
res = self.client.getServiceStats( self.args[0], self.args[1] )['Value']
except:
gLogger.exception( "Exception when calling ResourceStatusClient for %s %s" % ( self.args[0], self.args[1] ) )
return {'Result':'Unknown'}
return {'Result':res}
def __init__(self, clients=None):
""" Constructor
examples:
>>> pep = PEP()
>>> pep1 = PEP( { 'ResourceStatusClient' : ResourceStatusClient() } )
>>> pep2 = PEP( { 'ResourceStatusClient' : ResourceStatusClient(), 'ClientY' : None } )
:Parameters:
**clients** - [ None, `dict` ]
dictionary with clients to be used in the commands issued by the policies.
If not defined, the commands will import them. It is a measure to avoid
opening the same connection every time a policy is evaluated.
"""
if clients is None:
clients = {}
# PEP uses internally two of the clients: ResourceStatusClient and ResouceManagementClient
if 'ResourceStatusClient' in clients:
self.rsClient = clients['ResourceStatusClient']
else:
self.rsClient = ResourceStatusClient()
if 'ResourceManagementClient' in clients:
self.rmClient = clients['ResourceManagementClient']
else:
self.rmClient = ResourceManagementClient()
self.clients = clients
# Pass to the PDP the clients that are going to be used on the Commands
self.pdp = PDP(clients)
def doCommand( self ):
"""
Return getPeriods from ResourceStatus Client
- args[0] should be a ValidRes
- args[1] should be the name of the ValidRes
- args[2] should be the present status
- args[3] are the number of hours requested
"""
super( RSPeriods_Command, self ).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient()
try:
res = self.client.getPeriods( self.args[0], self.args[1], self.args[2], self.args[3] )['Value']
except:
gLogger.exception( "Exception when calling ResourceStatusClient for %s %s" % ( self.args[0], self.args[1] ) )
return {'Result':'Unknown'}
return {'Result':res}
class MonitoredStatus_Command(Command):
"""
The MonitoredStatus_Command class is a command class to know about
monitored status.
"""
def doCommand(self):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getMonitoredStatus`
:params:
:attr:`args`: a tuple
- `args[0]`: string - should be a ValidRes
- `args[1]`: string - should be the name of the ValidRes
- `args[2]`: optional string - a ValidRes (get status of THIS ValidRes
for name in args[1], will call getGeneralName)
:returns:
{'MonitoredStatus': 'Active'|'Probing'|'Banned'}
"""
super(MonitoredStatus_Command, self).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient(timeout=self.timeout)
try:
if len(self.args) == 3:
if ValidRes.index(self.args[2]) >= ValidRes.index(self.args[0]):
raise InvalidRes, where(self, self.doCommand)
toBeFound = self.client.getGeneralName(self.args[0], self.args[1], self.args[2])[0]
statuses = self.client.getMonitoredStatus(self.args[2], toBeFound)
else:
toBeFound = self.args[1]
statuses = self.client.getMonitoredStatus(self.args[0], toBeFound)
if not statuses:
gLogger.warn("No status found for %s" % toBeFound)
return {"Result": "Unknown"}
except:
gLogger.exception("Exception when calling ResourceStatusClient for %s %s" % (self.args[0], self.args[1]))
return {"Result": "Unknown"}
if len(statuses) == 1:
res = statuses[0]
else:
i = 0
for status in statuses:
ind = ValidStatus.index(status)
if ind > i:
i = ind
res = ValidStatus[i]
return {"Result": res}
doCommand.__doc__ = Command.doCommand.__doc__ + doCommand.__doc__
def test_fileOperations(self):
"""
this test requires the SE to be properly defined in the CS
"""
from DIRAC import gConfig
testSE = 'testSE'
rssClient = ResourceStatusClient()
result = rssClient.getStorageElementsList('Read')
#result = gConfig.getSections( '/Resources/StorageElements' )
#if result['OK'] and result['Value']:
# testSE = result['Value'][0]
if result['Ok']:
testSE = result['Value'][0]
result = self.fc.addFile({
testFile: {
'PFN': 'testfile',
'SE': testSE,
'Size': 0,
'GUID': 0,
'Checksum': '0'
}
})
self.assert_(result['OK'])
if gConfig.getValue(
'/Resources/StorageElements/%s/AccessProtocol.1/Host' % testSE,
''):
result = self.fc.getReplicas(testFile)
self.assert_(result['OK'])
self.assert_(testFile in result['Value']['Successful'])
def __init__(self, *args, **kwargs):
AgentModule.__init__(self, *args, **kwargs)
self.diracAdmin = None
self.default_value = None
self.rsClient = ResourceStatusClient()
def initialize(self):
# Attribute defined outside __init__
# pylint: disable-msg=W0201
try:
self.rsClient = ResourceStatusClient()
self.sitesFreqs = CS.getTypedDictRootedAtOperations(
'CheckingFreqs/SitesFreqs')
self.sitesToBeChecked = Queue.Queue()
self.siteNamesInCheck = []
self.maxNumberOfThreads = self.am_getOption('maxThreadsInPool', 1)
self.threadPool = ThreadPool(self.maxNumberOfThreads,
self.maxNumberOfThreads)
if not self.threadPool:
self.log.error('Can not create Thread Pool')
return S_ERROR('Can not create Thread Pool')
for _i in xrange(self.maxNumberOfThreads):
self.threadPool.generateJobAndQueueIt(self._executeCheck,
args=(None, ))
return S_OK()
except Exception:
errorStr = "SSInspectorAgent initialization"
self.log.exception(errorStr)
return S_ERROR(errorStr)
def __getSelectionData(self):
callback = {}
lhcbGroup = credentials.getSelectedGroup()
lhcbUser = str(credentials.getUsername())
RPC = getRPCClient( "ResourceStatus/ResourceStatus" )
client = ResourceStatusClient( serviceIn = RPC )
if len(request.params) > 0:
tmp = {}
for i in request.params:
tmp[i] = str(request.params[i])
callback["extra"] = tmp
####
result = client.getSitePresent( meta = { 'columns' : 'SiteName' } )
if result["OK"]:
sites = result["Value"]
try:
sites = list(sites)
except Exception,x:
gLogger.error("Exception during convertion to a list: %s" % str(x))
sites = [] # Will return error on length check
tier1 = gConfig.getValue("/Website/PreferredSites",[]) # Always return a list
if len(sites)>0:
tier1.reverse()
tier1 = [[x] for x in tier1]
sites = [x for x in sites if x not in tier1] # Removes sites which are in tier1 list
for i in tier1:
sites.insert(0,i)
sites.insert(0,["All"])
else:
sites = [["Nothing to display"]]
def initialize(self):
''' Standard initialize.
Uses the ProductionManager shifterProxy to modify the ResourceStatus DB
'''
self.rsClient = ResourceStatusClient()
return S_OK()
def __init__(self, name, decisionParams, enforcementResult, singlePolicyResults, clients=None):
super(EmailAction, self).__init__(name, decisionParams, enforcementResult, singlePolicyResults, clients)
if clients is not None and "ResourceStatusClient" in clients:
self.rsClient = clients["ResourceStatusClient"]
else:
self.rsClient = ResourceStatusClient()
def __init__(self, args=None, clients=None):
super(ServiceStatsCommand, self).__init__(args, clients)
if 'ResourceStatusClient' in self.apis:
self.rsClient = self.apis['ResourceStatusClient']
else:
self.rsClient = ResourceStatusClient()
def doCommand(self):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getMonitoredStatus`
:params:
:attr:`args`: a tuple
- `args[0]`: string - should be a ValidRes
- `args[1]`: string - should be the name of the ValidRes
- `args[2]`: optional string - a ValidRes (get status of THIS ValidRes
for name in args[1], will call getGeneralName)
:returns:
{'MonitoredStatus': 'Active'|'Probing'|'Banned'}
"""
super(MonitoredStatus_Command, self).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient(timeout=self.timeout)
try:
if len(self.args) == 3:
if ValidRes.index(self.args[2]) >= ValidRes.index(
self.args[0]):
raise InvalidRes, where(self, self.doCommand)
toBeFound = self.client.getGeneralName(self.args[0],
self.args[1],
self.args[2])[0]
statuses = self.client.getMonitoredStatus(
self.args[2], toBeFound)
else:
toBeFound = self.args[1]
statuses = self.client.getMonitoredStatus(
self.args[0], toBeFound)
if not statuses:
gLogger.warn("No status found for %s" % toBeFound)
return {'Result': 'Unknown'}
except:
gLogger.exception(
"Exception when calling ResourceStatusClient for %s %s" %
(self.args[0], self.args[1]))
return {'Result': 'Unknown'}
if len(statuses) == 1:
res = statuses[0]
else:
i = 0
for status in statuses:
ind = ValidStatus.index(status)
if ind > i:
i = ind
res = ValidStatus[i]
return {'Result': res}
def __init__(self):
""" Constructor
"""
self.log = gLogger.getSubLogger(self.__class__.__name__)
self.compoDB = ComponentMonitoringDB()
self.rsClient = ResourceStatusClient()
def initialize(self):
""" Standard initialize.
:return: S_OK
"""
self.rsClient = ResourceStatusClient()
return S_OK()
def doCommand(self, RSClientIn=None):
"""
Returns simple pilots efficiency
:attr:`args`:
- args[0]: string - should be a ValidRes
- args[1]: string - should be the name of the ValidRes
returns:
{
'Result': 'Good'|'Fair'|'Poor'|'Idle'|'Bad'
}
"""
super(PilotsEffSimple_Command, self).doCommand()
if self.args[0] in ('Service', 'Services'):
if RSClientIn is not None:
rsc = RSClientIn
else:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
rsc = ResourceStatusClient()
try:
name = rsc.getGeneralName(self.args[0], self.args[1],
'Site')['Value'][0]
except:
gLogger.error(
"PilotsEffSimple_Command: can't get a general name for %s %s"
% (self.args[0], self.args[1]))
return {'Result': 'Unknown'}
granularity = 'Site'
elif self.args[0] in ('Site', 'Sites', 'Resource', 'Resources'):
name = self.args[1]
granularity = self.args[0]
else:
raise InvalidRes, where(self, self.doCommand)
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.PilotsClient import PilotsClient
self.client = PilotsClient()
try:
res = self.client.getPilotsSimpleEff(granularity,
name,
timeout=self.timeout)
if res is None:
return {'Result': 'Idle'}
if res[name] is None:
return {'Result': 'Idle'}
except:
gLogger.exception("Exception when calling PilotsClient for %s %s" %
(granularity, name))
return {'Result': 'Unknown'}
return {'Result': res[name]}
def initialize(self):
"""TokenAgent initialization"""
self.notifyHours = self.am_getOption("notifyHours", self.notifyHours)
self.adminMail = self.am_getOption("adminMail", self.adminMail)
self.rsClient = ResourceStatusClient()
self.diracAdmin = DiracAdmin()
return S_OK()
def __init__(self):
"""
Constructor, initializes the rssClient.
"""
self.log = gLogger.getSubLogger(self.__class__.__name__)
self.rssConfig = RssConfiguration()
self.__opHelper = Operations()
self.rssFlag = ResourceStatus().rssFlag
self.rsClient = ResourceStatusClient()
def initialize(self):
"""Standard initialize.
:return: S_OK
"""
self.rsClient = ResourceStatusClient()
self.months = self.am_getOption("Months", self.months)
return S_OK()
def initialize( self ):
''' TokenAgent initialization
'''
self.notifyHours = self.am_getOption( 'notifyHours', self.notifyHours )
self.adminMail = self.am_getOption( 'adminMail', self.adminMail )
self.rsClient = ResourceStatusClient()
self.diracAdmin = DiracAdmin()
return S_OK()
def __init__(self, rsClient=None, rmClient=None):
self.GOCDBClient = GOCDBClient()
self.rsClient = ResourceStatusClient(
) if rsClient == None else rsClient
self.rmClient = ResourceManagementClient(
) if rmClient == None else rmClient
self.synclist = [
'Sites', 'Resources', 'StorageElements', 'Services',
'RegistryUsers'
]
def test__emailActionAgent():
rssClient = ResourceStatusClient()
# clean up
res = rssClient.delete('ResourceStatusCache')
assert res['OK'] is True
res = action.run()
assert res['OK'] is True
res = agent.execute()
assert res['OK'] is True
def __init__(self, granularity, name, status_type, pdp_decision, **kw):
ActionBase.__init__(self, granularity, name, status_type, pdp_decision,
**kw)
try:
self.rsClient = self.kw["Clients"]['ResourceStatusClient']
except KeyError:
self.rsClient = ResourceStatusClient()
try:
self.rmClient = self.kw["Clients"]['ResourceManagementClient']
except KeyError:
self.rmClient = ResourceManagementClient()
def __init__(self, args=None, clients=None):
super(PilotsEffSimpleCachedCommand, self).__init__(args, clients)
if 'ResourceStatusClient' in self.apis:
self.rsClient = self.apis['ResourceStatusClient']
else:
self.rsClient = ResourceStatusClient()
if 'ResourceManagementClient' in self.apis:
self.rmClient = self.apis['ResourceManagementClient']
else:
self.emClient = ResourceManagementClient()
def doCommand(self, RSClientIn = None):
"""
Returns simple pilots efficiency
:attr:`args`:
- args[0]: string - should be a ValidRes
- args[1]: string - should be the name of the ValidRes
returns:
{
'Result': 'Good'|'Fair'|'Poor'|'Idle'|'Bad'
}
"""
super(PilotsEffSimple_Command, self).doCommand()
if self.args[0] in ('Service', 'Services'):
if RSClientIn is not None:
rsc = RSClientIn
else:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
rsc = ResourceStatusClient()
try:
name = rsc.getGeneralName(self.args[0], self.args[1], 'Site')[0]
except:
gLogger.error("PilotsEffSimple_Command: can't get a general name for %s %s" %(self.args[0], self.args[1]))
return {'Result':'Unknown'}
granularity = 'Site'
elif self.args[0] in ('Site', 'Sites', 'Resource', 'Resources'):
name = self.args[1]
granularity = self.args[0]
else:
raise InvalidRes, where(self, self.doCommand)
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.PilotsClient import PilotsClient
self.client = PilotsClient()
try:
res = self.client.getPilotsSimpleEff(granularity, name, timeout = self.timeout)
if res is None:
return {'Result':'Idle'}
if res[name] is None:
return {'Result':'Idle'}
except:
gLogger.exception("Exception when calling PilotsClient for %s %s" %(granularity, name))
return {'Result':'Unknown'}
return {'Result':res[name]}
def getSiteMaskLogging(self, site=None, printOutput=False):
"""Retrieves site mask logging information.
Example usage:
>>> print diracAdmin.getSiteMaskLogging('LCG.AUVER.fr')
{'OK': True, 'Value': }
:returns: S_OK,S_ERROR
"""
result = self.__checkSiteIsValid(site)
if not result['OK']:
return result
rssClient = ResourceStatusClient()
result = rssClient.selectStatusElement('Site',
'History',
name=site,
statusType='ComputingAccess')
if not result['OK']:
return result
siteDict = {}
for logTuple in result['Value']:
status, reason, siteName, dateEffective, dateTokenExpiration, eType, sType, eID, lastCheckTime, author = logTuple
result = getSiteFullNames(siteName)
if not result['OK']:
continue
for sName in result['Value']:
if site is None or (site and site == sName):
siteDict.setdefault(sName, [])
siteDict[sName].append((status, reason, dateEffective,
author, dateTokenExpiration))
if printOutput:
if site:
print '\nSite Mask Logging Info for %s\n' % site
else:
print '\nAll Site Mask Logging Info\n'
for site, tupleList in siteDict.items():
if not site:
print '\n===> %s\n' % site
for tup in tupleList:
print str( tup[0] ).ljust( 8 ) + str( tup[1] ).ljust( 20 ) + \
'( ' + str( tup[2] ).ljust( len( str( tup[2] ) ) ) + ' ) "' + str( tup[3] ) + '"'
print ' '
return S_OK(siteDict)
def __getMode( self ):
"""
Get's flag defined ( or not ) on the RSSConfiguration. If defined as 1,
we use RSS, if not, we use CS.
"""
res = self.rssConfig.getConfigState()
if res == 'Active':
if self.rssClient is None:
self.rssClient = ResourceStatusClient()
return True
self.rssClient = None
return False
def __getMode(self):
"""
Gets flag defined (or not) on the RSSConfiguration.
If defined as 'Active', we use RSS, if not, we use the CS when possible (and WMS for Sites).
"""
res = self.rssConfig.getConfigState()
if res == 'Active':
if self.rssClient is None:
self.rssClient = ResourceStatusClient()
return True
self.rssClient = None
return False
def __init__(self):
"""
Constructor, initializes the rssClient.
"""
self.log = gLogger.getSubLogger(self.__class__.__name__)
self.rssConfig = RssConfiguration()
self.__opHelper = Operations()
self.rssFlag = ResourceStatus().rssFlag
self.rsClient = ResourceStatusClient()
cacheLifeTime = int(self.rssConfig.getConfigCache())
# RSSCache only affects the calls directed to RSS, if using the CS it is not used.
self.rssCache = RSSCache(cacheLifeTime, self.__updateRssCache)
class StorageElementsStats_Command( Command ):
"""
The StorageElementsStats_Command class is a command class to know about
present storageElementss stats
"""
def doCommand( self ):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getStorageElementsStats`
:params:
:attr:`args`: a tuple
- `args[0]` should be in ['Site', 'Resource']
- `args[1]` should be the name of the Site or Resource
:returns:
"""
super( StorageElementsStats_Command, self ).doCommand()
if self.args[0] in ( 'Service', 'Services' ):
granularity = 'Site'
name = self.args[1].split( '@' )[1]
elif self.args[0] in ( 'Site', 'Sites', 'Resource', 'Resources' ):
granularity = self.args[0]
name = self.args[1]
else:
raise InvalidRes, where( self, self.doCommand )
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient( timeout = self.timeout )
try:
resR = self.client.getStorageElementsStats( granularity, name, 'Read' )['Value']
resW = self.client.getStorageElementsStats( granularity, name, 'Write' )['Value']
except:
gLogger.exception( "Exception when calling ResourceStatusClient for %s %s" % ( granularity, name ) )
return {'Result':'Unknown'}
res = {}
for key in ValidStatus:
res[ key ] = resR[ key ] + resW[ key ]
return {'Result':res}
doCommand.__doc__ = Command.doCommand.__doc__ + doCommand.__doc__
def doCommand(self):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getServiceStats`
:params:
:attr:`args`: a tuple
- args[1]: a ValidRes
- args[0]: should be the name of the Site
:returns:
{'Active':xx, 'Probing':yy, 'Banned':zz, 'Total':xyz}
"""
super(ServiceStats_Command, self).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient(timeout=self.timeout)
try:
res = self.client.getServiceStats(self.args[0], self.args[1])
except:
gLogger.exception("Exception when calling ResourceStatusClient for %s %s" % (self.args[0], self.args[1]))
return {"Result": "Unknown"}
return {"Result": res}
class ServiceStats_Command( Command ):
"""
The ServiceStats_Command class is a command class to know about
present services stats
"""
def doCommand( self ):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getServiceStats`
:params:
:attr:`args`: a tuple
- args[1]: a ValidRes
- args[0]: should be the name of the Site
:returns:
{'Active':xx, 'Probing':yy, 'Banned':zz, 'Total':xyz}
"""
super( ServiceStats_Command, self ).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient( timeout = self.timeout )
try:
res = self.client.getServiceStats( self.args[0], self.args[1] )['Value']
except:
gLogger.exception( "Exception when calling ResourceStatusClient for %s %s" % ( self.args[0], self.args[1] ) )
return {'Result':'Unknown'}
return {'Result':res}
doCommand.__doc__ = Command.doCommand.__doc__ + doCommand.__doc__
def doCommand(self):
"""
Return getPeriods from ResourceStatus Client
- args[0] should be a ValidRes
- args[1] should be the name of the ValidRes
- args[2] should be the present status
- args[3] are the number of hours requested
"""
super(RSPeriods_Command, self).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient()
try:
res = self.client.getPeriods(self.args[0], self.args[1], self.args[2], self.args[3])
except:
gLogger.exception("Exception when calling ResourceStatusClient for %s %s" % (self.args[0], self.args[1]))
return {"Result": "Unknown"}
return {"Result": res}
def __init__(self, granularity, name, status_type, pdp_decision, **kw):
ActionBase.__init__( self, granularity, name, status_type, pdp_decision, **kw )
try: self.rsClient = self.kw["Clients"][ 'ResourceStatusClient' ]
except KeyError: self.rsClient = ResourceStatusClient()
try: self.rmClient = self.kw["Clients"][ 'ResourceManagementClient' ]
except KeyError: self.rmClient = ResourceManagementClient()
class ResourceStats_Command( Command ):
"""
The ResourceStats_Command class is a command class to know about
present resources stats
"""
def doCommand( self ):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getResourceStats`
:params:
:attr:`args`: a tuple
- `args[0]` string, a ValidRes. Should be in ('Site', 'Service')
- `args[1]` should be the name of the Site or Service
:returns:
"""
super( ResourceStats_Command, self ).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient( timeout = self.timeout )
try:
res = self.client.getResourceStats( self.args[0], self.args[1] )['Value']
except:
gLogger.exception( "Exception when calling ResourceStatusClient for %s %s" % ( self.args[0], self.args[1] ) )
return {'Result':'Unknown'}
return {'Result':res}
doCommand.__doc__ = Command.doCommand.__doc__ + doCommand.__doc__
def __init__(self, rStatus=None, rManagement=None, defaultStatus="Unknown"):
# Warm up local CS
CSHelpers.warmUp()
if rStatus is None:
self.rStatus = ResourceStatusClient()
if rManagement is None:
self.rManagement = ResourceManagementClient()
self.defaultStatus = defaultStatus
self.rssConfig = RssConfiguration()
self.tokenOwner = "rs_svc"
result = getProxyInfo()
if result['OK']:
self.tokenOwner = result['Value']['username']
def __init__( self, clients = None ):
""" Constructor
examples:
>>> pep = PEP()
>>> pep1 = PEP( { 'ResourceStatusClient' : ResourceStatusClient() } )
>>> pep2 = PEP( { 'ResourceStatusClient' : ResourceStatusClient(), 'ClientY' : None } )
:Parameters:
**clients** - [ None, `dict` ]
dictionary with clients to be used in the commands issued by the policies.
If not defined, the commands will import them. It is a measure to avoid
opening the same connection every time a policy is evaluated.
"""
if clients is None:
clients = {}
# PEP uses internally two of the clients: ResourceStatusClient and ResouceManagementClient
if 'ResourceStatusClient' in clients:
self.rsClient = clients[ 'ResourceStatusClient' ]
else:
self.rsClient = ResourceStatusClient()
if 'ResourceManagementClient' in clients:
self.rmClient = clients[ 'ResourceManagementClient' ]
else:
self.rmClient = ResourceManagementClient()
self.clients = clients
# Pass to the PDP the clients that are going to be used on the Commands
self.pdp = PDP( clients )
def __init__( self, rsClient = None, rmClient = None ):
self.GOCDBClient = GOCDBClient()
self.rsClient = ResourceStatusClient() if rsClient == None else rsClient
self.rmClient = ResourceManagementClient() if rmClient == None else rmClient
self.synclist = [ 'Sites', 'Resources', 'StorageElements', 'Services', 'RegistryUsers' ]
def doCommand(self):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getResourceStats`
:params:
:attr:`args`: a tuple
- `args[0]` string, a ValidRes. Should be in ('Site', 'Service')
- `args[1]` should be the name of the Site or Service
:returns:
"""
super(ResourceStats_Command, self).doCommand()
if self.client is None:
from DIRAC.ResourceStatusSystem.Client.ResourceStatusClient import ResourceStatusClient
self.client = ResourceStatusClient(timeout=self.timeout)
try:
res = self.client.getResourceStats(self.args[0], self.args[1])
except:
gLogger.exception("Exception when calling ResourceStatusClient for %s %s" % (self.args[0], self.args[1]))
return {"Result": "Unknown"}
return {"Result": res}
def initialize(self):
''' Standard initialize.
Uses the ProductionManager shifterProxy to modify the ResourceStatus DB
'''
self.maxCacheLifetime = self.am_getOption('maxCacheLifetime',
self.maxCacheLifetime)
self.maxHistoryLifetime = self.am_getOption('maxHistoryLifetime',
self.maxHistoryLifetime)
self.maxLogLifetime = self.am_getOption('maxLogLifetime',
self.maxLogLifetime)
self.rsClient = ResourceStatusClient()
self.rmClient = ResourceManagementClient()
return S_OK()
def initialize( self ):
# Attribute defined outside __init__
# pylint: disable-msg=W0201
try:
self.rsClient = ResourceStatusClient()
self.resourcesFreqs = CS.getTypedDictRootedAtOperations( 'CheckingFreqs/ResourcesFreqs' )
self.resourcesToBeChecked = Queue.Queue()
self.resourceNamesInCheck = []
self.maxNumberOfThreads = self.am_getOption( 'maxThreadsInPool', 1 )
self.threadPool = ThreadPool( self.maxNumberOfThreads,
self.maxNumberOfThreads )
if not self.threadPool:
self.log.error( 'Can not create Thread Pool' )
return S_ERROR( 'Can not create Thread Pool' )
for _i in xrange( self.maxNumberOfThreads ):
self.threadPool.generateJobAndQueueIt( self._executeCheck, args = ( None, ) )
return S_OK()
except Exception:
errorStr = "RSInspectorAgent initialization"
self.log.exception( errorStr )
return S_ERROR( errorStr )
class RSPeriodsCommand( Command ):
def __init__( self, args = None, clients = None ):
super( RSPeriodsCommand, self ).__init__( args, clients )
if 'ResourceStatusClient' in self.apis:
self.rsClient = self.apis[ 'ResourceStatusClient' ]
else:
self.rsClient = ResourceStatusClient()
def doCommand( self ):
"""
Return getPeriods from ResourceStatus Client
- args[0] should be a ValidElement
- args[1] should be the name of the ValidElement
- args[2] should be the present status
- args[3] are the number of hours requested
"""
# try:
res = self.rsClient.getPeriods( self.args[0], self.args[1], self.args[2], self.args[3] )
# except Exception, e:
# _msg = '%s (%s): %s' % ( self.__class__.__name__, self.args, e )
# gLogger.exception( _msg )
# return S_ERROR( _msg )
return res
def getSiteMaskLogging( self, site = None, printOutput = False ):
"""Retrieves site mask logging information.
Example usage:
>>> print diracAdmin.getSiteMaskLogging('LCG.AUVER.fr')
{'OK': True, 'Value': }
:returns: S_OK,S_ERROR
"""
result = self.__checkSiteIsValid( site )
if not result['OK']:
return result
rssClient = ResourceStatusClient()
result = rssClient.selectStatusElement( 'Site', 'History', name = site,
statusType = 'ComputingAccess' )
if not result['OK']:
return result
siteDict = {}
for logTuple in result['Value']:
status,reason,siteName,dateEffective,dateTokenExpiration,eType,sType,eID,lastCheckTime,author = logTuple
result = getSiteFullNames( siteName )
if not result['OK']:
continue
for sName in result['Value']:
if site is None or (site and site == sName):
siteDict.setdefault( sName, [] )
siteDict[sName].append( (status,reason,dateEffective,author,dateTokenExpiration) )
if printOutput:
if site:
print '\nSite Mask Logging Info for %s\n' % site
else:
print '\nAll Site Mask Logging Info\n'
for site, tupleList in siteDict.items():
if not site:
print '\n===> %s\n' % site
for tup in tupleList:
print str( tup[0] ).ljust( 8 ) + str( tup[1] ).ljust( 20 ) + \
'( ' + str( tup[2] ).ljust( len( str( tup[2] ) ) ) + ' ) "' + str( tup[3] ) + '"'
print ' '
return S_OK( siteDict )
def __init__(self, name, decisionParams, enforcementResult, singlePolicyResults, clients=None):
super(LogStatusAction, self).__init__(name, decisionParams, enforcementResult, singlePolicyResults, clients)
if clients is not None and "ResourceStatusClient" in clients:
self.rsClient = clients["ResourceStatusClient"]
else:
self.rsClient = ResourceStatusClient()
def __init__( self, args = None, clients = None ):
super( ServiceStatsCommand, self ).__init__( args, clients )
if 'ResourceStatusClient' in self.apis:
self.rsClient = self.apis[ 'ResourceStatusClient' ]
else:
self.rsClient = ResourceStatusClient()
def initialize( self ):
''' Standard initialize.
Uses the ProductionManager shifterProxy to modify the ResourceStatus DB
'''
self.rsClient = ResourceStatusClient()
return S_OK()
class LogStatusAction(BaseAction):
'''
Action that registers on the database a new entry on the <element>Status table.
It adds or modifies if the record exists on the table.
'''
def __init__(self, name, decisionParams, enforcementResult, singlePolicyResults,
clients=None):
super(LogStatusAction, self).__init__(name, decisionParams, enforcementResult,
singlePolicyResults, clients)
if clients is not None and 'ResourceStatusClient' in clients:
self.rsClient = clients['ResourceStatusClient']
else:
self.rsClient = ResourceStatusClient()
def run(self):
'''
Checks it has the parameters it needs and tries to addOrModify in the
database.
'''
# Minor security checks
element = self.decisionParams['element']
if element is None:
return S_ERROR('element should not be None')
name = self.decisionParams['name']
if name is None:
return S_ERROR('name should not be None')
statusType = self.decisionParams['statusType']
if statusType is None:
return S_ERROR('statusType should not be None')
status = self.enforcementResult['Status']
if status is None:
return S_ERROR('status should not be None')
elementType = self.decisionParams['elementType']
if elementType is None:
return S_ERROR('elementType should not be None')
reason = self.enforcementResult['Reason']
if reason is None:
return S_ERROR('reason should not be None')
# Truncate reason to fit in database column
reason = (reason[:508] + '..') if len(reason) > 508 else reason
resLogUpdate = self.rsClient.addOrModifyStatusElement(element, 'Status',
name=name, statusType=statusType,
status=status, elementType=elementType,
reason=reason
)
return resLogUpdate
def __init__( self ): """ Constructor """ self.log = gLogger.getSubLogger( self.__class__.__name__ ) self.compoDB = ComponentMonitoringDB() self.rsClient = ResourceStatusClient()
def initialize( self ):
""" Standard initialize.
:return: S_OK
"""
self.rsClient = ResourceStatusClient()
return S_OK()
def __init__( self, decissionParams, enforcementResult, singlePolicyResults, clients = None):
super( LogStatusAction, self ).__init__( decissionParams, enforcementResult,
singlePolicyResults, clients )
self.actionName = 'LogStatusAction'
if clients is not None and 'ResourceStatusClient' in clients:
self.rsClient = clients[ 'ResourceStatusClient' ]
else:
self.rsClient = ResourceStatusClient()
def initialize(self):
""" TokenAgent initialization
"""
self.notifyHours = self.am_getOption("notifyHours", self.notifyHours)
self.adminMail = self.am_getOption("adminMail", self.adminMail)
self.rsClient = ResourceStatusClient()
self.diracAdmin = DiracAdmin()
return S_OK()
class LogStatusAction(BaseAction):
"""
Action that registers on the database a new entry on the <element>Status table.
It adds or modifies if the record exists on the table.
"""
def __init__(self, name, decisionParams, enforcementResult, singlePolicyResults, clients=None):
super(LogStatusAction, self).__init__(name, decisionParams, enforcementResult, singlePolicyResults, clients)
if clients is not None and "ResourceStatusClient" in clients:
self.rsClient = clients["ResourceStatusClient"]
else:
self.rsClient = ResourceStatusClient()
def run(self):
"""
Checks it has the parameters it needs and tries to addOrModify in the
database.
"""
# Minor security checks
element = self.decisionParams["element"]
if element is None:
return S_ERROR("element should not be None")
name = self.decisionParams["name"]
if name is None:
return S_ERROR("name should not be None")
statusType = self.decisionParams["statusType"]
if statusType is None:
return S_ERROR("statusType should not be None")
status = self.enforcementResult["Status"]
if status is None:
return S_ERROR("status should not be None")
elementType = self.decisionParams["elementType"]
if elementType is None:
return S_ERROR("elementType should not be None")
reason = self.enforcementResult["Reason"]
if reason is None:
return S_ERROR("reason should not be None")
# Truncate reason to fit in database column
reason = (reason[:508] + "..") if len(reason) > 508 else reason
resLogUpdate = self.rsClient.addOrModifyStatusElement(
element, "Status", name=name, statusType=statusType, status=status, elementType=elementType, reason=reason
)
return resLogUpdate
def __init__( self, args = None, clients = None ):
super( PilotsEffSimpleCachedCommand, self ).__init__( args, clients )
if 'ResourceStatusClient' in self.apis:
self.rsClient = self.apis[ 'ResourceStatusClient' ]
else:
self.rsClient = ResourceStatusClient()
if 'ResourceManagementClient' in self.apis:
self.rmClient = self.apis[ 'ResourceManagementClient' ]
else:
self.emClient = ResourceManagementClient()
def initialize( self ):
''' Standard initialize.
Uses the ProductionManager shifterProxy to modify the ResourceStatus DB
'''
self.maxCacheLifetime = self.am_getOption( 'maxCacheLifetime', self.maxCacheLifetime )
self.maxHistoryLifetime = self.am_getOption( 'maxHistoryLifetime', self.maxHistoryLifetime )
self.maxLogLifetime = self.am_getOption( 'maxLogLifetime', self.maxLogLifetime )
self.rsClient = ResourceStatusClient()
self.rmClient = ResourceManagementClient()
return S_OK()
def initialize( self ):
''' TokenAgent initialization
Uses the ProductionManager shifterProxy to modify the ResourceStatus DB
'''
self.notifyHours = self.am_getOption( 'notifyHours', self.notifyHours )
self.rsClient = ResourceStatusClient()
self.rmClient = ResourceManagementClient()
self.noClient = NotificationClient()
self.diracAdmin = DiracAdmin()
return S_OK()
class StorageElementsStatsCommand( Command ):
"""
The StorageElementsStats_Command class is a command class to know about
present storageElementss stats
"""
def __init__( self, args = None, clients = None ):
super( StorageElementsStatsCommand, self ).__init__( args, clients )
if 'ResourceStatusClient' in self.apis:
self.rsClient = self.apis[ 'ResourceStatusClient' ]
else:
self.rsClient = ResourceStatusClient()
def doCommand( self ):
"""
Uses :meth:`DIRAC.ResourceStatusSystem.Client.ResourceStatusClient.getStorageElementStats`
:params:
:attr:`args`: a tuple
- `args[0]` should be in ['Site', 'Resource']
- `args[1]` should be the name of the Site or Resource
:returns:
"""
# try:
if self.args[0] == 'Service':
granularity = 'Site'
name = self.args[1].split( '@' )[1]
elif self.args[0] in [ 'Site', 'Resource' ]:
granularity = self.args[0]
name = self.args[1]
else:
return self.returnERROR( S_ERROR( '%s is not a valid granularity' % self.args[ 0 ] ) )
res = self.rsClient.getStorageElementStats( granularity, name, statusType = None )
if not res[ 'OK' ]:
return self.returnERROR( res )
# except Exception, e:
# _msg = '%s (%s): %s' % ( self.__class__.__name__, self.args, e )
# gLogger.exception( _msg )
# return S_ERROR( _msg )
return res
