def validatesite(self, sitename):
if lexicon.anstr(sitename) & (sitename == 'summary'):
return True
if lexicon.tier(sitename):
sitelist = popCommonDB.getSitesList(DBUSER)
if sitename in sitelist:
return True
raise Paramvalidationexception('sitename', 'param must be a valid site name')
def validatesite(self, sitename):
if lexicon.anstr(sitename) & (sitename == 'summary'):
return True
if lexicon.tier(sitename):
sitelist = popCommonDB.getSitesList(DBUSER)
if sitename in sitelist:
return True
raise Paramvalidationexception('sitename',
'param must be a valid site name')
def validatedataset(self, dataset):
if lexicon.dataset(dataset):
dslist = popCommonDB.getDataSetList(DBUSER)
dslist = map(lambda x: x["COLLNAME"], dslist)
if dataset in dslist:
return True
raise Paramvalidationexception('dataset', 'param must be a valid dataset name')
def validateprocesseddataset(self, procdataset):
if lexicon.processeddataset(procdataset):
dslist = popCommonDB.getProcessedDataSetList(DBUSER)
dslist = map(lambda x: x["COLLNAME"], dslist)
if procdataset in dslist:
return True
raise Paramvalidationexception('processeddataset', 'param must be a valid processed dataset name')
def validateprocesseddataset(self, procdataset):
if lexicon.processeddataset(procdataset):
dslist = popCommonDB.getProcessedDataSetList(DBUSER)
dslist = map(lambda x: x["COLLNAME"], dslist)
if procdataset in dslist:
return True
raise Paramvalidationexception(
'processeddataset', 'param must be a valid processed dataset name')
def validatedataset(self, dataset):
if lexicon.dataset(dataset):
dslist = popCommonDB.getDataSetList(DBUSER)
dslist = map(lambda x: x["COLLNAME"], dslist)
if dataset in dslist:
return True
raise Paramvalidationexception('dataset',
'param must be a valid dataset name')
def validatedatatier(self, datatier):
if lexicon.datatier(datatier):
dtlist = popCommonDB.getDataTierList(DBUSER)
dtlist = map(lambda x: x["COLLNAME"], dtlist)
dtlist.append('ALL')
if datatier in dtlist:
return True
raise Paramvalidationexception('datatier', 'param must be a valid datatier name')
def validatedatatier(self, datatier):
if lexicon.datatier(datatier):
dtlist = popCommonDB.getDataTierList(DBUSER)
dtlist = map(lambda x: x["COLLNAME"], dtlist)
dtlist.append('ALL')
if datatier in dtlist:
return True
raise Paramvalidationexception('datatier',
'param must be a valid datatier name')
def get_json_data(self,
site='T%',
source='',
timestart=datetime.now(),
timestop=(datetime.now() - timedelta(days=30))):
self.validateSiteName(site)
if not Lexicon.accsource(source):
raise popularityInterfaceException(
"Given source (access data source) is not valid")
par = victorinterfaceparams()
try:
par.setSiteName(site)
logger.info('debug. siteName = %s' % par.SiteName)
if source == '':
if par.SiteName == 'T2_CH_CERN' or par.SiteName == 'T0_CH_CERN':
source = 'xrootd'
par.SiteName = 'T2_CH_CERN'
else:
source = 'crab'
par.setSource(source)
if self.lastAcc:
pop_data = victorinterfaceDB.WhatInSiteWithStatLastAcc(
collType='BlocksStat', params=par)
else:
par.setTStart(timestart)
par.setTStop(timestop)
pop_data = victorinterfaceDB.WhatInSiteWithStat(
collType='BlocksStat', params=par)
except Paramvalidationexception as e:
raise popularityInterfaceException(e.getmessage())
except victorinterfaceDB.PopularityDBException as dbe:
raise popularityInterfaceException(dbe.getmessage())
except Exception as ex:
raise popularityInterfaceException(ex)
try:
pop_data[site]
except KeyError:
logger.warning('WARNING: empty popularity results for %s' % site)
return pop_data
def get_json_data(self, site, source, timestart=None, timestop=None):
self.validateSiteName(site)
params = {'sitename':site, 'tstart': timestart, 'tstop': timestop}
if not timestart and not timestop:
params = {'sitename':site}
if Lexicon.accsource(source):
params['source'] = source
else:
raise popularityInterfaceException("Given source (access data source) is not valid")
pop_data = httpInterface.get_json_data(self, params)
try:
pop_data[site]
except KeyError:
logger.warning('WARNING: empty popularity results for %s' % site)
return pop_data
def get_json_data(self, site='T%', source='', timestart=datetime.now(), timestop=(datetime.now() - timedelta(days=30))):
self.validateSiteName(site)
if not Lexicon.accsource(source):
raise popularityInterfaceException("Given source (access data source) is not valid")
par = victorinterfaceparams()
try:
par.setSiteName(site)
logger.info('debug. siteName = %s' % par.SiteName)
if source=='':
if par.SiteName == 'T2_CH_CERN' or par.SiteName == 'T0_CH_CERN':
source = 'xrootd'
par.SiteName = 'T2_CH_CERN'
else:
source = 'crab'
par.setSource(source)
if self.lastAcc:
pop_data = victorinterfaceDB.WhatInSiteWithStatLastAcc(collType='BlocksStat', params=par)
else:
par.setTStart(timestart)
par.setTStop(timestop)
pop_data = victorinterfaceDB.WhatInSiteWithStat(collType='BlocksStat', params=par)
except Paramvalidationexception as e:
raise popularityInterfaceException(e.getmessage())
except victorinterfaceDB.PopularityDBException as dbe:
raise popularityInterfaceException(dbe.getmessage())
except Exception as ex:
raise popularityInterfaceException(ex)
try:
pop_data[site]
except KeyError:
logger.warning('WARNING: empty popularity results for %s' % site)
return pop_data
def validateaggregation(self, aggr):
if lexicon.anstr(aggr) & (aggr in self.aggregationvalues):
return True
raise Paramvalidationexception(
'aggr', 'param must be value in %s' % self.aggregationvalues)
def validateHostName(self, hostname):
#pat = re.compile('^http[s]*://[a-zA-Z0-9\-\.]+$')
if not Lexicon.hostname(hostname):
msg = 'Invalid hostname: %s' % hostname
raise ValueError(msg)
def validateorder(self, order):
if lexicon.anstr(order) & (order in self.ordervalues):
return True
raise Paramvalidationexception(
'order', 'param must be a value in %s' % self.ordervalues)
def validateDir(self, dirname):
if lexicon.dirname(dirname):
return True
raise Paramvalidationexception('dirname', 'param must be a valid directory name')
def validatedate(self, inputdate):
if lexicon.datestr(inputdate):
return True
raise Paramvalidationexception('inputdate', 'param must be a valid date')
def validateSite(self, sitename):
if (sitename == '') | (lexicon.wildcardtier(sitename)):
return True
raise Paramvalidationexception('sitename', 'param must be a valid site name')
def validateSource(self, source):
if lexicon.accsource(source):
return True
raise Paramvalidationexception('source', 'param must be a valid source name')
def validatedate(self, inputdate):
if lexicon.datestr(inputdate):
return True
raise Paramvalidationexception('inputdate', 'param must be a valid date')
def validateSiteName(self, sitename):
#pat = re.compile('^T[0-9][a-zA-Z0-9_]+$')
if not Lexicon.wildcardtier(sitename):
msg = 'Invalid sitename: %s' % sitename
raise ValueError(msg)
def validateHostName(self, hostname):
#pat = re.compile('^http[s]*://[a-zA-Z0-9\-\.]+$')
if not Lexicon.hostname(hostname):
msg = 'Invalid hostname: %s' % hostname
raise ValueError(msg)
def validateaggregation(self, aggr):
if lexicon.anstr(aggr) & (aggr in self.aggregationvalues):
return True
raise Paramvalidationexception('aggr', 'param must be value in %s' % self.aggregationvalues)
def validateHostName(self, hostname):
#pat = re.compile('^http[s]*://[a-zA-Z0-9\-\.]+$')
if not Lexicon.hostname(hostname):
raise PopularityHttpInterfaceException("Given hostname has not a valid format")
def validateorder(self, order):
if lexicon.anstr(order) & (order in self.ordervalues):
return True
raise Paramvalidationexception('order', 'param must be a value in %s' % self.ordervalues)
def validateSiteName(self, sitename):
#pat = re.compile('^T[0-9][a-zA-Z0-9_]+$')
if not Lexicon.wildcardtier(sitename):
raise popularityInterfaceException("Given hostname has not a valid format")
def validateSiteName(self, sitename):
#pat = re.compile('^T[0-9][a-zA-Z0-9_]+$')
if not Lexicon.wildcardtier(sitename):
msg = 'Invalid sitename: %s' % sitename
raise ValueError(msg)
def validateHostName(self, hostname):
#pat = re.compile('^http[s]*://[a-zA-Z0-9\-\.]+$')
if not Lexicon.hostname(hostname):
raise PopularityHttpInterfaceException(
"Given hostname has not a valid format")
