def __getHistory(self, state):
"""
Just get the history based on state
Return resulting list
"state" can be either "Save" or "Load"
"""
gLogger.info("Running getHistory( %s )" % state)
msg = "getHistory() for %s@%s" % (getUsername(), getSelectedGroup())
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions(opt, 5)
upc = UserProfileClient("Default", getRPCClient)
group = str(getSelectedGroup())
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar(profile_name)
gLogger.info(result)
if not result["OK"]:
if result["Message"].find("No data") < 0:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
history = list()
else:
history = result["Value"]
if not isinstance(history, list):
err = "List expected at: %s" % profile_name
gLogger.error("Result %s: %s" % (msg, err))
return S_ERROR(err)
if (len(history) > history_length):
history = result[history_length]
gLogger.info("Result %s: %s" % (msg, history))
return S_OK(history)
def htmlUserInfo():
username = credentials.getUsername()
if not username or username == "anonymous":
htmlData = "Anonymous"
else:
selectedGroup = credentials.getSelectedGroup()
availableGroups = [(groupName,
diracURL(controller='web/userdata',
action='changeGroup',
id=groupName))
for groupName in credentials.getAvailableGroups()]
htmlData = "%s@%s" % (username,
yuiWidgets.dropDownMenu("UserGroupPos",
selectedGroup,
availableGroups))
dn = credentials.getUserDN()
if dn:
htmlData += " (%s)" % dn
else:
if 'REQUEST_URI' in request.environ:
uri = str(request.environ['REQUEST_URI'])
else:
uri = ""
htmlData += " (<a href='https://%s%s'>certificate login</a>)" % (str(
request.environ['HTTP_HOST']), uri)
return htmlData
def __getUserLayout(self):
gLogger.info("Running getUserLayout()")
msg = "getUserLayout() for %s@%s" % (getUsername(), getSelectedGroup())
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.retrieveAllVars()
gLogger.debug(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
layouts = result["Value"]
data = list()
for name, value in layouts.items():
result = self.__getPermissions(name)
if not result["OK"]:
perm = result["Message"]
else:
perm = result["Value"]
if perm.has_key("ReadAccess"):
perm = perm["ReadAccess"]
else:
perm = "Undefined"
if value.has_key("group"):
group = value["group"]
else:
group = "Undefined"
perm = perm.capitalize()
data.append({"name": name, "permission": perm, "group": group})
gLogger.info("Result %s: %s" % (msg, data))
return {"success": "true", "result": data}
def __getUniqueKeyValues(self, typeName):
userGroup = getSelectedGroup()
if 'NormalUser' in CS.getPropertiesForGroup(userGroup):
cacheKey = (getUsername(), userGroup, getSelectedSetup(), typeName)
else:
cacheKey = (userGroup, getSelectedSetup(), typeName)
data = AccountingplotsController.__keysCache.get(cacheKey)
if not data:
rpcClient = getRPCClient("Accounting/ReportGenerator")
retVal = rpcClient.listUniqueKeyValues(typeName)
if 'rpcStub' in retVal:
del (retVal['rpcStub'])
if not retVal['OK']:
return retVal
#Site ordering based on TierLevel / alpha
if 'Site' in retVal['Value']:
siteLevel = {}
for siteName in retVal['Value']['Site']:
sitePrefix = siteName.split(".")[0].strip()
level = gConfig.getValue(
"/Resources/Sites/%s/%s/MoUTierLevel" %
(sitePrefix, siteName), 10)
if level not in siteLevel:
siteLevel[level] = []
siteLevel[level].append(siteName)
orderedSites = []
for level in sorted(siteLevel):
orderedSites.extend(sorted(siteLevel[level]))
retVal['Value']['Site'] = orderedSites
data = retVal
AccountingplotsController.__keysCache.add(cacheKey, 300, data)
return data
def __getUserLayout( self ) :
gLogger.info( "Running getUserLayout()" )
msg = "getUserLayout() for %s@%s" % ( getUsername() , getSelectedGroup() )
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.retrieveAllVars()
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
layouts = result[ "Value" ]
data = list()
for name , value in layouts.items():
result = self.__getPermissions( name )
if not result[ "OK" ]:
perm = result[ "Message" ]
else:
perm = result[ "Value" ]
if perm.has_key( "ReadAccess" ):
perm = perm[ "ReadAccess" ]
else:
perm = "Undefined"
if value.has_key( "group" ):
group = value[ "group" ]
else:
group = "Undefined"
data.append( { "name" : name , "permission" : perm , "group" : group } )
gLogger.info( "Result %s: %s" % ( msg , data ) )
return { "success" : "true" , "result" : data }
def __loadLayout(self):
gLogger.info("Running loadLayout()")
msg = "loadLayout() for %s@%s" % (getUsername(), getSelectedGroup())
result = self.__params2string(LOAD_LAYOUT_ARGS)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
args = result["Value"]
name = args["name"]
user = args["user"]
group = args["group"]
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.retrieveVarFromUser(user, group, name)
gLogger.debug(result)
if not result["OK"]:
if result["Message"].find("No data") < 0:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
err = "No data found for '%s' by %s@%s" % (name, user, group)
gLogger.error("Result %s: %s" % (msg, err))
return {"success": "false", "error": err}
layout = result["Value"]
for i in LOAD_LAYOUT_ARGS: # Add params to layout if they are absent
if not layout.has_key(i):
layout[i] = args[i]
result = self.__setHistory(args, "Load")
history = dict()
if not result["OK"]:
history["Load"] = result["Message"]
else:
history["Load"] = result["Value"]
gLogger.info("Result %s: %s AND %s" % (msg, layout, history))
return {"success": "true", "result": layout, "history": history}
def __sendMessage(self):
"""
This function is used to send a mail to specific group of DIRAC user
Expected parameters from request are group, title, body
"""
gLogger.info("Start message broadcasting")
checkUserCredentials()
dn = getUserDN()
if not dn:
error = "Certificate is not loaded in the browser or DN is absent"
gLogger.error("Service response: %s" % error)
return {"success": "false", "error": error}
username = getUsername()
if username == "anonymous":
error = "Sending an anonymous message is forbidden"
gLogger.error("Service response: %s" % error)
return {"success": "false", "error": error}
gLogger.info("DN: %s" % dn)
email = gConfig.getValue("/Registry/Users/%s/Email" % username, "")
gLogger.debug("/Registry/Users/%s/Email - '%s'" % (username, email))
emil = email.strip()
if not email:
error = "Can't find value for option /Registry/Users/%s/Email" % user
gLogger.error("Service response: %s" % error)
return {"success": "false", "error": error}
test = ["group", "title", "body"]
for i in test:
if not i in request.params:
error = "The required parameter %s is absent in request" % i
gLogger.error("Service response: %s" % error)
return {"success": "false", "error": error}
group = request.params["group"]
users = gConfig.getValue("/Registry/Groups/%s/Users" % group, [])
if not len(users) > 0:
error = "No users for %s group found" % group
gLogger.error("Service response: %s" % error)
return {"success": "false", "error": error}
sendDict = self.getMailDict(users)
if not len(sendDict) > 0:
error = "Can't get a mail address for users in %s group" % group
gLogger.debug("Service response: %s" % error)
return {"success": "false", "error": error}
gLogger.debug("Final dictionary with mails to be used %s" % sendDict)
title = self.checkUnicode(request.params["title"])
gLogger.debug("email title: %s" % title)
body = self.checkUnicode(request.params["body"])
gLogger.debug("email body: %s" % body)
self.__messageLog(user, group, title, body)
return self.sendMail(sendDict, title, body, email)
def getUserData():
userData = []
username = credentials.getUsername()
if not username or username == "anonymous":
userData.append("username : '******'")
else:
userData.append("username : '******'" % username)
userData.append("group : '%s'" % credentials.getSelectedGroup())
properties = credentials.getProperties(credentials.getSelectedGroup())
if len(properties) > 0:
userData.append("groupProperties : %s" % properties)
else:
userData.append("groupProperties : []")
availableGroups = list()
for groupName in credentials.getAvailableGroups():
properties = credentials.getProperties(groupName)
if not len(properties) > 0:
continue
if ("Pilot" in properties) or ("GenericPilot" in properties):
continue
url = diracURL(controller="web/userdata", action="changeGroup", id=groupName)
availableGroups.append("{ text : '%s', url : '%s' }" % (groupName, url))
userData.append("groupMenu : [%s]" % ",".join(availableGroups))
dn = credentials.getUserDN()
if not dn:
if "REQUEST_URI" in request.environ:
uri = str(request.environ["REQUEST_URI"])
else:
uri = ""
dn = '<a href="https://%s%s">certificate login</a>' % (str(request.environ["HTTP_HOST"]), uri)
userData.append("DN : '%s'" % dn)
return "{%s}" % ",".join(userData)
def __loadLayout( self ):
gLogger.info( "Running loadLayout()" )
msg = "loadLayout() for %s@%s" % ( getUsername() , getSelectedGroup() )
result = self.__params2string( LOAD_LAYOUT_ARGS )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
args = result[ "Value" ]
name = args[ "name" ]
user = args[ "user" ]
group = args[ "group" ]
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.retrieveVarFromUser( user , group, name )
gLogger.debug( result )
if not result[ "OK" ]:
if result[ "Message" ].find( "No data" ) < 0 :
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
err = "No data found for '%s' by %s@%s" % ( name , user , group )
gLogger.error( "Result %s: %s" % ( msg , err ) )
return { "success" : "false" , "error" : err }
layout = result[ "Value" ]
for i in LOAD_LAYOUT_ARGS : # Add params to layout if they are absent
if not layout.has_key( i ):
layout[ i ] = args[ i ]
result = self.__setHistory( args , "Load" )
history = dict()
if not result[ "OK" ]:
history[ "Load" ] = result[ "Message" ]
else:
history[ "Load" ] = result[ "Value" ]
gLogger.info( "Result %s: %s AND %s" % ( msg , layout , history ) )
return { "success" : "true" , "result" : layout , "history" : history }
def display(self):
gLogger.info( "Running display()" )
msg = "display() for %s@%s" % ( getUsername() , getSelectedGroup() )
if not authorizeAction():
gLogger.info( "Result %s: %s" % ( msg , "Not authorized" ) )
return render( "/login.mako" )
result = self.__convert()
if not result[ "OK" ]:
c.error = result[ "Message" ]
gLogger.error( "Result %s: %s" % ( msg , c.error ) )
return render( "/error.mako" )
c.select = dict()
history = dict()
for i in [ "Save" , "Load" ]:
result = self.__getHistory( i )
if not result[ "OK" ]:
history[ i ] = result[ "Message" ]
else:
history[ i ] = result[ "Value" ]
c.select[ "history" ] = history
result = self.__lastUsed()
if not result[ "OK" ]:
c.select[ "layout" ] = ""
c.select[ "error" ] = result[ "Message" ]
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return render("web/Presenter.mako")
c.select[ "layout" ] = result[ "Value" ]
gLogger.info( "Result %s: %s" % ( msg , c.select ) )
return render("web/Presenter.mako")
def __lastUsed( self ):
gLogger.info( "Running lastUsed()" )
msg = "lastUsed() for %s@%s" % ( getUsername() , getSelectedGroup() )
result = self.__getHistory( "Load" )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
history = result[ "Value" ]
if not len( history ) > 0:
err = "Load history is empty"
gLogger.error( "Result %s: %s" % ( msg , err ) )
return S_ERROR( err )
args = history[ 0 ]
name = args[ "name" ]
user = args[ "user" ]
group = args[ "group" ]
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.retrieveVarFromUser( user , group, name )
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
layout = result[ "Value" ]
for i in LOAD_LAYOUT_ARGS : # Add params to layout if they are absent
if not layout.has_key( i ):
layout[ i ] = args[ i ]
gLogger.info( "Result %s: %s" % ( msg , layout ) )
return S_OK( layout )
def getUserData():
userData = []
username = credentials.getUsername()
if not username or username == "anonymous":
userData.append( "username : '******'" )
else:
userData.append( "username : '******'" % username )
userData.append( "group : '%s'" % credentials.getSelectedGroup() )
properties = credentials.getProperties( credentials.getSelectedGroup() )
if len( properties ) > 0:
userData.append( "groupProperties : %s" % properties )
else:
userData.append( "groupProperties : []" )
availableGroups = [ "{ text : '%s', url : '%s' }" % ( groupName,
diracURL( controller = 'web/userdata',
action = 'changeGroup',
id = groupName )
) for groupName in credentials.getAvailableGroups() ]
userData.append( "groupMenu : [%s]" % ",".join( availableGroups ) )
dn = credentials.getUserDN()
if not dn:
if 'REQUEST_URI' in request.environ:
uri = str( request.environ[ 'REQUEST_URI' ] )
else:
uri = ""
dn = "<a href=\"https://%s%s\">certificate login</a>" % ( str( request.environ[ 'HTTP_HOST' ] ), uri )
userData.append( "DN : '%s'" % dn )
return "{%s}" % ",".join( userData )
def __getUniqueKeyValues( self, typeName ):
userGroup = getSelectedGroup()
if 'NormalUser' in CS.getPropertiesForGroup( userGroup ):
cacheKey = ( getUsername(), userGroup, getSelectedSetup(), typeName )
else:
cacheKey = ( userGroup, getSelectedSetup(), typeName )
data = AcctController.__keysCache.get( cacheKey )
if not data:
rpcClient = getRPCClient( "Accounting/ReportGenerator" )
retVal = rpcClient.listUniqueKeyValues( typeName )
if 'rpcStub' in retVal:
del( retVal[ 'rpcStub' ] )
if not retVal[ 'OK' ]:
return retVal
#Site ordering based on TierLevel / alpha
if 'Site' in retVal[ 'Value' ]:
siteLevel = {}
for siteName in retVal[ 'Value' ][ 'Site' ]:
sitePrefix = siteName.split( "." )[0].strip()
level = gConfig.getValue( "/Resources/Sites/%s/%s/MoUTierLevel" % ( sitePrefix, siteName ), 10 )
if level not in siteLevel:
siteLevel[ level ] = []
siteLevel[ level ].append( siteName )
orderedSites = []
for level in sorted( siteLevel ):
orderedSites.extend( sorted( siteLevel[ level ] ) )
retVal[ 'Value' ][ 'Site' ] = orderedSites
data = retVal
AcctController.__keysCache.add( cacheKey, 300, data )
return data
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 submit(self):
pagestart = time()
RPC = getRPCClient("WorkloadManagement/JobMonitoring")
user = str(credentials.getUsername())
result = RPC.getOwners()
if result["OK"]:
defaultGroup = gConfig.getValue("/Registry/DefaultGroup","")
if defaultGroup == "":
return {"success":"false","error":"Option /Registry/DefaultGroup is undefined, please set the default group in the CS"}
group = str(credentials.getSelectedGroup())
groupProperty = credentials.getProperties(group)
if user not in result["Value"] and ( "JobAdministrator" or "JobSharing" ) not in groupProperty:
c.result = {"success":"false","error":"You don't have any jobs in the DIRAC system"}
return c.result
else:
c.result = {"success":"false","error":result["Message"]}
return c.result
req = self.__request()
gLogger.always("getJobPageSummaryWeb(%s,%s,%s,%s)" % (req,globalSort,pageNumber,numberOfJobs))
result = RPC.getJobPageSummaryWeb(req,globalSort,pageNumber,numberOfJobs)
gLogger.always(" - REZ: " %result)
if result["OK"]:
result = result["Value"]
gLogger.info("ReS",result)
if result.has_key("TotalRecords"):
if result["TotalRecords"] > 0:
if result.has_key("ParameterNames") and result.has_key("Records"):
if len(result["ParameterNames"]) > 0:
if len(result["Records"]) > 0:
c.result = []
jobs = result["Records"]
head = result["ParameterNames"]
headLength = len(head)
for i in jobs:
tmp = {}
for j in range(0,headLength):
tmp[head[j]] = i[j]
c.result.append(tmp)
total = result["TotalRecords"]
timestamp = Time.dateTime().strftime("%Y-%m-%d %H:%M [UTC]")
if result.has_key("Extras"):
st = self.__dict2string(req)
extra = result["Extras"]
c.result = {"success":"true","result":c.result,"total":total,"extra":extra,"request":st,"date":timestamp}
else:
c.result = {"success":"true","result":c.result,"total":total,"date":timestamp}
else:
c.result = {"success":"false","result":"","error":"There are no data to display"}
else:
c.result = {"success":"false","result":"","error":"ParameterNames field is missing"}
else:
c.result = {"success":"false","result":"","error":"Data structure is corrupted"}
else:
c.result = {"success":"false","result":"","error":"There were no data matching your selection"}
else:
c.result = {"success":"false","result":"","error":"Data structure is corrupted"}
else:
c.result = {"success":"false","error":result["Message"]}
gLogger.info("\033[0;31mJOB SUBMIT REQUEST:\033[0m %s" % (time() - pagestart))
return c.result
def __getHistory( self , state ):
"""
Just get the history based on state
Return resulting list
"state" can be either "Save" or "Load"
"""
gLogger.info( "Running getHistory( %s )" % state )
msg = "getHistory() for %s@%s" % ( getUsername() , getSelectedGroup() )
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions( opt , 5 )
upc = UserProfileClient( "Default" , getRPCClient )
group = str( getSelectedGroup() )
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar( profile_name )
gLogger.info( result )
if not result[ "OK" ]:
if result[ "Message" ].find( "No data" ) < 0 :
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
history = list()
else:
history = result[ "Value" ]
if not isinstance( history , list ):
err = "List expected at: %s" % profile_name
gLogger.error( "Result %s: %s" % ( msg , err ) )
return S_ERROR( err )
if( len( history ) > history_length ):
history = result[ history_length ]
gLogger.info( "Result %s: %s" % ( msg , history ) )
return S_OK( history )
def getUserData():
userData = []
username = credentials.getUsername()
if not username or username == "anonymous":
userData.append( "username : '******'" )
else:
userData.append( "username : '******'" % username )
userData.append( "group : '%s'" % credentials.getSelectedGroup() )
properties = credentials.getProperties( credentials.getSelectedGroup() )
if len( properties ) > 0:
userData.append( "groupProperties : %s" % properties )
else:
userData.append( "groupProperties : []" )
availableGroups = list()
for groupName in credentials.getAvailableGroups():
properties = credentials.getProperties( groupName )
if not len( properties ) > 0:
continue
if ( "Pilot" in properties ) or ( "GenericPilot" in properties ):
continue
url = diracURL( controller = 'web/userdata',
action = 'changeGroup',
id = groupName )
availableGroups.append( "{ text : '%s', url : '%s' }" %
( groupName , url ) )
userData.append( "groupMenu : [%s]" % ",".join( availableGroups ) )
dn = credentials.getUserDN()
if not dn:
if 'REQUEST_URI' in request.environ:
uri = str( request.environ[ 'REQUEST_URI' ] )
else:
uri = ""
dn = "<a href=\"https://%s%s\">certificate login</a>" % ( str( request.environ[ 'HTTP_HOST' ] ), uri )
userData.append( "DN : '%s'" % dn )
return "{%s}" % ",".join( userData )
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 display(self):
gLogger.info("Running display()")
msg = "display() for %s@%s" % (getUsername(), getSelectedGroup())
if not authorizeAction():
gLogger.info("Result %s: %s" % (msg, "Not authorized"))
return render("/login.mako")
result = self.__convert()
if not result["OK"]:
c.error = result["Message"]
gLogger.error("Result %s: %s" % (msg, c.error))
return render("/error.mako")
c.select = dict()
history = dict()
for i in ["Save", "Load"]:
result = self.__getHistory(i)
if not result["OK"]:
history[i] = result["Message"]
else:
history[i] = result["Value"]
c.select["history"] = history
result = self.__lastUsed()
if not result["OK"]:
c.select["layout"] = ""
c.select["error"] = result["Message"]
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return render("web/Presenter.mako")
c.select["layout"] = result["Value"]
gLogger.info("Result %s: %s" % (msg, c.select))
return render("web/Presenter.mako")
def __lastUsed(self):
gLogger.info("Running lastUsed()")
msg = "lastUsed() for %s@%s" % (getUsername(), getSelectedGroup())
result = self.__getHistory("Load")
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
history = result["Value"]
if not len(history) > 0:
err = "Load history is empty"
gLogger.error("Result %s: %s" % (msg, err))
return S_ERROR(err)
args = history[0]
name = args["name"]
user = args["user"]
group = args["group"]
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.retrieveVarFromUser(user, group, name)
gLogger.debug(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
layout = result["Value"]
for i in LOAD_LAYOUT_ARGS: # Add params to layout if they are absent
if not layout.has_key(i):
layout[i] = args[i]
gLogger.info("Result %s: %s" % (msg, layout))
return S_OK(layout)
def getStatsForUser(self, forceRefresh=False):
userName = credentials.getUsername()
if userName == 'anonymous':
return {'totalNots': 0}
self.__refresh(forceRefresh)
if userName not in self.__stats:
return {'totalNots': 0}
return self.__stats[userName]
def getStatsForUser( self, forceRefresh = False ):
userName = credentials.getUsername()
if userName == 'anonymous':
return { 'totalNots' : 0 }
self.__refresh( forceRefresh )
if userName not in self.__stats:
return { 'totalNots' : 0 }
return self.__stats[ userName ]
def __getModificator(self):
rpcClient = getRPCClient(gConfig.getValue("/DIRAC/Configuration/MasterServer", "Configuration/Server"))
commiter = "%s@%s - %s" % (
credentials.getUsername(),
credentials.getSelectedGroup(),
Time.dateTime().strftime("%Y-%m-%d %H:%M:%S"),
)
return Modificator(rpcClient, commiter)
def __getModificator(self):
rpcClient = getRPCClient(
gConfig.getValue("/DIRAC/Configuration/MasterServer",
"Configuration/Server"))
commiter = "%s@%s - %s" % (
credentials.getUsername(), credentials.getSelectedGroup(),
Time.dateTime().strftime("%Y-%m-%d %H:%M:%S"))
return Modificator(rpcClient, commiter)
def __request(self):
req = {}
lhcbGroup = credentials.getSelectedGroup()
lhcbUser = str(credentials.getUsername())
global pageNumber
if request.params.has_key("id") and len(request.params["id"]) > 0:
pageNumber = 0
req["JobID"] = str(request.params["id"])
elif request.params.has_key("expand") and len(request.params["expand"]) > 0:
globalSort = [["GridSite","ASC"]]
numberOfJobs = 500
pageNumber = 0
req["ExpandSite"] = str(request.params["expand"])
else:
result = gConfig.getOption("/Website/ListSeparator")
if result["OK"]:
separator = result["Value"]
else:
separator = ":::"
pageNumber = 0
numberOfJobs = 500
if request.params.has_key("prod") and len(request.params["prod"]) > 0:
if str(request.params["prod"]) != "All":
req["JobGroup"] = str(request.params["prod"]).split(separator)
if request.params.has_key("site") and len(request.params["site"]) > 0:
if str(request.params["site"]) != "All":
tmp = str(request.params["site"]).split(separator)
if len(tmp) == 1:
req["ExpandSite"] = tmp[0]
else:
req["GridSite"] = tmp
if request.params.has_key("stat") and len(request.params["stat"]) > 0:
if str(request.params["stat"]) != "All":
req["Status"] = str(request.params["stat"]).split(separator)
if request.params.has_key("minorstat") and len(request.params["minorstat"]) > 0:
if str(request.params["minorstat"]) != "All":
req["MinorStatus"] = str(request.params["minorstat"]).split(separator)
if request.params.has_key("app") and len(request.params["app"]) > 0:
if str(request.params["app"]) != "All":
req["ApplicationStatus"] = str(request.params["app"]).split(separator)
# if lhcbGroup == "lhcb" or lhcbGroup == "lhcb_user":
# req["Owner"] = str(lhcbUser)
else:
if request.params.has_key("owner") and len(request.params["owner"]) > 0:
if str(request.params["owner"]) != "All":
req["Owner"] = str(request.params["owner"]).split(separator)
if request.params.has_key("date") and len(request.params["date"]) > 0:
if str(request.params["date"]) != "YYYY-mm-dd":
req["LastUpdate"] = str(request.params["date"])
if request.params.has_key("sort") and len(request.params["sort"]) > 0:
globalSort = str(request.params["sort"])
key,value = globalSort.split(" ")
globalSort = [[str(key),str(value)]]
else:
# globalSort = [["JobID","DESC"]]
globalSort = [["GridSite","ASC"]]
gLogger.info("REQUEST:",req)
return req
def kaboom(self):
uList = [str(getUsername())]
result = list()
for i in [USER_PROFILE_NAME, "Default"]:
upc = UserProfileClient(i, getRPCClient)
tmp = upc.deleteProfiles(uList)
allvar = upc.retrieveAllVars()
result.append(allvar)
return result
def kaboom(self):
uList = [ str( getUsername() ) ]
result = list()
for i in [ USER_PROFILE_NAME , "Default" ]:
upc = UserProfileClient( i , getRPCClient )
tmp = upc.deleteProfiles( uList )
allvar = upc.retrieveAllVars()
result.append( allvar )
return result
def getDatasetList( self ):
callback = {}
callback['datasets'] = []
basePath = '/belle2/user/belle/' + credentials.getUsername()
try:
amga = AmgaClient()
dirs = amga.getSubdirectories(basePath, relative=True)
except Exception, v:
gLogger.error("section does not exist", "%s -> %s" % (sectionPath, str(v)))
def deleteNotifications( self, notifsIds ):
userName = credentials.getUsername()
if userName == 'anonymous':
return S_OK()
ntfCli = self.getNtfClient()
result = ntfCli.removeNotificationsForUser( userName, notifsIds )
if not result[ 'OK' ]:
return S_ERROR( result[ 'Message' ] )
self.__refresh( forceRefresh = True )
return S_OK()
def getNotificationsForUser(self):
userName = credentials.getUsername()
self.__refresh(forceRefresh=True)
gLogger.info("Retrieving notifications for user %s" % userName)
gLogger.info(str(self.__notifications))
if userName in self.__notifications:
gLogger.info("User %s nas notifications" % userName)
return self.__notifications[userName]
gLogger.info("User %s does not have notifications" % userName)
return {}
def deleteNotifications(self, notifsIds):
userName = credentials.getUsername()
if userName == 'anonymous':
return S_OK()
ntfCli = self.getNtfClient()
result = ntfCli.removeNotificationsForUser(userName, notifsIds)
if not result['OK']:
return S_ERROR(result['Message'])
self.__refresh(forceRefresh=True)
return S_OK()
def __loadLast(self):
gLogger.info("Running loadLast()")
msg = "loadLast() for %s@%s" % (getUsername(), getSelectedGroup())
result = self.__lastUsed()
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
layout = result["Value"]
gLogger.info("Result %s: %s" % (msg, layout))
return {"success": "true", "result": layout}
def __loadLast( self ):
gLogger.info( "Running loadLast()" )
msg = "loadLast() for %s@%s" % ( getUsername() , getSelectedGroup() )
result = self.__lastUsed()
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
layout = result[ "Value" ]
gLogger.info( "Result %s: %s" % ( msg , layout ) )
return { "success" : "true" , "result" : layout }
def getNotificationsForUser( self ):
userName = credentials.getUsername()
self.__refresh( forceRefresh = True );
gLogger.info( "Retrieving notifications for user %s" % userName )
gLogger.info( str( self.__notifications ) )
if userName in self.__notifications:
gLogger.info( "User %s nas notifications" % userName )
return self.__notifications[ userName ]
gLogger.info( "User %s does not have notifications" % userName )
return {}
def getProjectsList( self ):
try:
start = int( request.params[ 'start' ] )
except:
start = 0
try:
limit = int( request.params[ 'limit' ] )
except:
limit = 0
try:
sortField = str( request.params[ 'sortField' ] ).replace( "_", "." )
sortDir = str( request.params[ 'sortDirection' ] )
sort = [ ( sortField, sortDir ) ]
except:
return S_ERROR( "Oops! Couldn't understand the request" )
condDict = {}
#This is our connection to the Job database
rpcClient = getRPCClient( "WorkloadManagement/JobMonitoring" )
# use the last 2 weeks of job data, to speed loading time
#lastFortnight = (datetime.today() - timedelta(365/26)).isoformat()
lastFortnight = (datetime.today() - timedelta(365/360)).isoformat()
username = credentials.getUsername()
group = credentials.getSelectedGroup()
if group != 'dirac_admin':
condDict = {'Owner': username}
result = rpcClient.getJobGroups( condDict, lastFortnight )
#result = rpcClient.getJobGroups()
if not result[ 'OK' ]:
return result
data = { 'numRecords' : len(result[ 'Value' ]), 'projects' : [] }
for record in result['Value']:
rD = {}
counters = rpcClient.getCounters(['Status', 'Owner','OwnerGroup','LastUpdateTime','SubmissionTime'], {'JobGroup' : record})
if not counters['OK']:
return counters
else:
rD['LastUpdate'] = self.timeToNUnitAgo(self.mostRecentTime(counters['Value'], 'LastUpdateTime'))
#rD['counters'] = counters['Value']
rD['percentage'] = self.statusToPercentage(counters['Value'])
rD['colours'] = self.statusToColours(counters['Value'])
if rD['percentage'] == 1:
if rD['colours'][0] > 0:
rD['status'] = "Done - with failures"
else:
rD['status'] = "Done"
else:
rD['status'] = "Running"
rD['SubmissionTime'] = str(self.mostRecentTime(counters['Value'],'SubmissionTime'))
#cheat - get the first owner as they're all the same
rD['Owner'] = counters["Value"][0][0]["Owner"]
rD['OwnerGroup'] = counters["Value"][0][0]["OwnerGroup"]
rD['proj_Name'] = record
data['projects'].append( rD )
return data
def display(self):
pagestart = time()
group = credentials.getSelectedGroup()
if group == "visitor" and credentials.getUserDN == "":
return render("/login.mako")
c.select = self.__getSelectionData()
if not c.select.has_key("extra"):
groupProperty = credentials.getProperties(group)
if ( "JobAdministrator" or "JobSharing" ) not in groupProperty: #len(groupProperty) == 1 and groupProperty[0] == "NormalUser":
c.select["extra"] = {"owner":credentials.getUsername()}
return render("jobs/JobMonitor.mako")
def __request(self):
req = {}
lhcbGroup = credentials.getSelectedGroup()
lhcbUser = str(credentials.getUsername())
global pageNumber
if request.params.has_key("id") and len(request.params["id"]) > 0:
pageNumber = 0
req["JobID"] = str(request.params["id"])
elif request.params.has_key("expand") and len(request.params["expand"]) > 0:
globalSort = [["GridSite","ASC"]]
numberOfJobs = 500
pageNumber = 0
req["ExpandSite"] = str(request.params["expand"])
else:
pageNumber = 0
numberOfJobs = 500
if request.params.has_key("prod") and len(request.params["prod"]) > 0:
if str(request.params["prod"]) != "All":
req["JobGroup"] = str(request.params["prod"]).split('::: ')
if request.params.has_key("site") and len(request.params["site"]) > 0:
if str(request.params["site"]) != "All":
tmp = str(request.params["site"]).split('::: ')
if len(tmp) == 1:
req["ExpandSite"] = tmp[0]
else:
req["GridSite"] = tmp
if request.params.has_key("stat") and len(request.params["stat"]) > 0:
if str(request.params["stat"]) != "All":
req["Status"] = str(request.params["stat"]).split('::: ')
if request.params.has_key("minorstat") and len(request.params["minorstat"]) > 0:
if str(request.params["minorstat"]) != "All":
req["MinorStatus"] = str(request.params["minorstat"]).split('::: ')
if request.params.has_key("app") and len(request.params["app"]) > 0:
if str(request.params["app"]) != "All":
req["ApplicationStatus"] = str(request.params["app"]).split('::: ')
# if lhcbGroup == "lhcb" or lhcbGroup == "lhcb_user":
# req["Owner"] = str(lhcbUser)
else:
if request.params.has_key("owner") and len(request.params["owner"]) > 0:
if str(request.params["owner"]) != "All":
req["Owner"] = str(request.params["owner"]).split('::: ')
if request.params.has_key("date") and len(request.params["date"]) > 0:
if str(request.params["date"]) != "YYYY-mm-dd":
req["LastUpdate"] = str(request.params["date"])
if request.params.has_key("sort") and len(request.params["sort"]) > 0:
globalSort = str(request.params["sort"])
key,value = globalSort.split(" ")
globalSort = [[str(key),str(value)]]
else:
# globalSort = [["JobID","DESC"]]
globalSort = [["GridSite","ASC"]]
gLogger.info("REQUEST:",req)
return req
def proxyUpload(self):
"""
Get p12 file and passwords as input. Split p12 to user key and certificate
and creating proxy for groups user belongs to. Upload proxy to proxy store
"""
# Otherwise the browser would offer to download a file
response.headers['Content-type'] = "text/html"
username = getUsername()
gLogger.info("Start upload proxy out of p12 for user: %s" % (username))
disclaimer = "\nNo proxy was created\nYour private info was safely deleted"
disclaimer = disclaimer + " from DIRAC service"
if username == "anonymous":
error = "Please, send a registration request first"
gLogger.error("Anonymous is not allowed")
gLogger.debug("Service response: %s" % error)
return {"success": "false", "error": error}
groupList = getAvailableGroups()
groups = ", ".join(groupList)
gLogger.info("Available groups for the user %s: %s" %
(username, groups))
if not len(groupList) > 0:
gLogger.error("User is not registered in any group")
error = "Seems that user %s is not register in any group" % username
error = error + disclaimer
gLogger.debug("Service response: %s" % error)
return {"success": "false", "error": error}
store = list()
gLogger.debug("Request's body:")
for key in request.params.keys():
try:
gLogger.debug("%s - %s" % (key, request.params[key]))
except Exception, x:
gLogger.error("Exception: %s" % str(x))
error = "An exception has happen '%s'" % str(x)
error = error + disclaimer
gLogger.debug("Service response: %s" % error)
return {"success": "false", "error": error}
try:
if request.params[key].filename:
name = request.params[key].filename
name = name.strip()
if name[-4:] == ".p12":
gLogger.info(".p12 in filename detected")
if request.params["pass_p12"]:
fileObject = request.params[key]
fileObject.p12 = str(request.params["pass_p12"])
gLogger.info(".p12 password detected")
store.append(fileObject)
gLogger.info("Certificate object is loaded")
except Exception, x:
gLogger.debug("Non fatal for logic, exception happens: %s" %
str(x))
pass
def markNotificationsAsSeen( self, seen, notifsIds ):
userName = credentials.getUsername()
if userName == 'anonymous':
return S_OK()
ntfCli = self.getNtfClient()
if seen:
result = ntfCli.markNotificationsAsRead( userName, notifsIds )
else:
result = ntfCli.markNotificationsAsNotRead( userName, notifsIds )
if not result[ 'OK' ]:
return S_ERROR( result[ 'Message' ] )
self.__refresh( forceRefresh = True )
return S_OK()
def markNotificationsAsSeen(self, seen, notifsIds):
userName = credentials.getUsername()
if userName == 'anonymous':
return S_OK()
ntfCli = self.getNtfClient()
if seen:
result = ntfCli.markNotificationsAsRead(userName, notifsIds)
else:
result = ntfCli.markNotificationsAsNotRead(userName, notifsIds)
if not result['OK']:
return S_ERROR(result['Message'])
self.__refresh(forceRefresh=True)
return S_OK()
def proxyUpload(self):
"""
Get p12 file and passwords as input. Split p12 to user key and certificate
and creating proxy for groups user belongs to. Upload proxy to proxy store
"""
# Otherwise the browser would offer to download a file
response.headers['Content-type'] = "text/html"
username = getUsername()
gLogger.info("Start upload proxy out of p12 for user: %s" % (username))
disclaimer = "\nNo proxy was created\nYour private info was safely deleted"
disclaimer = disclaimer + " from DIRAC service"
if username == "anonymous":
error = "Please, send a registration request first"
gLogger.error("Anonymous is not allowed")
gLogger.debug("Service response: %s" % error)
return {"success":"false","error":error}
groupList = getAvailableGroups()
groups = ", ".join(groupList)
gLogger.info("Available groups for the user %s: %s" % (username,groups))
if not len(groupList) > 0:
gLogger.error("User is not registered in any group")
error = "Seems that user %s is not register in any group" % username
error = error + disclaimer
gLogger.debug("Service response: %s" % error)
return {"success":"false","error":error}
store = list()
gLogger.debug("Request's body:")
for key in request.params.keys():
try:
gLogger.debug("%s - %s" % (key,request.params[key]))
except Exception,x:
gLogger.error("Exception: %s" % str(x))
error = "An exception has happen '%s'" % str(x)
error = error + disclaimer
gLogger.debug("Service response: %s" % error)
return {"success":"false","error":error}
try:
if request.params[key].filename:
name = request.params[key].filename
name = name.strip()
if name[-4:] == ".p12":
gLogger.info(".p12 in filename detected")
if request.params["pass_p12"]:
fileObject = request.params[key]
fileObject.p12 = str(request.params["pass_p12"])
gLogger.info(".p12 password detected")
store.append(fileObject)
gLogger.info("Certificate object is loaded")
except Exception,x:
gLogger.debug("Non fatal for logic, exception happens: %s" % str(x))
pass
def display(self):
checkUserCredentials()
dn = getUserDN()
user = getUsername()
group = getSelectedGroup()
gLogger.always("User: %s, Group: %s, DN: %s" % (user, group, dn))
templates = ["reg_%s.mako" % i for i in ["done", "form", "info"]]
html = [
"reg_%s.html" % i
for i in ["footer", "header", "conditions", "form", "done"]
]
files = templates + html
basedir = os.path.join(rootPath, "Web", "dirac", "templates")
for i in files:
f = os.path.join(basedir, i)
if not os.path.exists(f):
gLogger.error("File does not exists: %s" % f)
return render("web/External.mako")
if dn and user == "anonymous":
upc = UserProfileClient("Registration", getRPCClient)
result = upc.retrieveVar(dn)
if result["OK"]:
c.sent = result["Value"]
return render("/reg_done.mako")
else:
return render("/reg_form.mako")
if not dn or dn == "":
return render("/reg_info.mako")
if "site" not in request.params:
c.select = gConfig.getValue("/Website/DefaultExternalURL",
"http://diracgrid.org")
return render("web/External.mako")
# No idea what this code should do...
if request.params.has_key("site") and len(request.params["site"]) > 0:
if str(request.params["site"]) != "All":
c.select = str(request.params["site"])
gLogger.debug("Request's body:")
for key in request.params.keys():
if not key == "site" and len(request.params[key]) > 0:
c.select = c.select + "&" + key + "=" + request.params[
key]
try:
gLogger.debug("%s - %s" %
(key, request.params[key]))
except Exception, x:
gLogger.error("Exception: %s" % str(x))
pass
def __getPermissions( self , name = False ):
gLogger.info( "getPermissions( %s )" % name )
msg = "getPermissions() for %s@%s" % ( getUsername() , getSelectedGroup() )
if not name:
err = "'name' argument for getPermissions function is absent"
gLogger.error( "Result %s: %s" % ( msg , err ) )
return S_ERROR( err )
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.getVarPermissions( name )
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
gLogger.info( "Result %s: %s" % ( msg , result[ "Value" ] ) )
return S_OK( result[ "Value" ] )
def action(self, act=None):
"""
"""
RPC = getRPCClient("WorkloadManagement/WMSAdministrator")
if not "name" in request.params:
return {"success": "false", "error": "Name of site is undefined"}
site = request.params["name"]
sites = site.split(",")
user = getUsername()
group = getSelectedGroup()
if not "comment" in request.params:
comment = "%s by %s@%s" % (act, user, group)
comment = request.params["comment"]
if not act in ["Allow", "Ban"]:
return {
"success": "false",
"error": "Action %s is unsupported" % act
}
gc = GeneralController()
gc.action = act
gc.actionSuccess = list()
gc.actionFailed = list()
gc.prefix = "Site"
for i in sites:
i = i.strip()
if act is "Allow":
result = RPC.allowSite(i, comment)
elif act is "Ban":
result = RPC.banSite(i, comment)
else:
continue
gLogger.debug("RPC return: %s" % result)
if not result["OK"]:
error = "%s: %s" % (i, result["Message"])
gc.actionFailed.append(error)
gLogger.error("Failure during %s host %s" % (act, i))
continue
gc.actionSuccess.append(i)
gLogger.info("Successfully %s host %s" % (act, i))
return gc.aftermath()
def __delAllData(self):
gLogger.info("__delAllData(%s) function")
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
username = getUsername()
if not type(username) == type({}):
username = list(username)
gLogger.info("upc.deleteProfiles(%s)" % username)
result = upc.deleteProfiles(username)
gLogger.debug(result)
if not result["OK"]:
gLogger.error(result["Message"])
return {"success":"false","error":result["Message"]}
result = self.__delHistory()
if not result["OK"]:
gLogger.error(result["Message"])
return self.__getData()
def action( self , act = None ):
"""
"""
RPC = getRPCClient( "WorkloadManagement/WMSAdministrator" )
if not "name" in request.params:
return { "success" : "false" , "error" : "Name of site is undefined" }
site = request.params["name"]
sites = site.split( "," )
user = getUsername()
group = getSelectedGroup()
if not "comment" in request.params:
comment = "%s by %s@%s" % ( act , user , group )
comment = request.params["comment"]
if not act in [ "Allow" , "Ban" ]:
return { "success" : "false" , "error" : "Action %s is unsupported" % act }
gc = GeneralController()
gc.action = act
gc.actionSuccess = list()
gc.actionFailed = list()
gc.prefix = "Site"
for i in sites:
i = i.strip()
if act is "Allow":
result = RPC.allowSite( i , comment )
elif act is "Ban":
result = RPC.banSite( i , comment )
else:
continue
gLogger.debug( "RPC return: %s" % result )
if not result["OK"]:
error = "%s: %s" % ( i , result[ "Message" ] )
gc.actionFailed.append( error )
gLogger.error( "Failure during %s host %s" % ( act , i ) )
continue
gc.actionSuccess.append( i )
gLogger.info( "Successfully %s host %s" % ( act , i ) )
return gc.aftermath()
def __saveLayout( self ):
gLogger.info( "Running saveLayout()" )
msg = "saveLayout() for %s@%s" % ( getUsername() , getSelectedGroup() )
result = self.__params2string( SAVE_LAYOUT_ARGS )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
args = result[ "Value" ]
name = args[ "name" ]
user = args[ "user" ]
group = args[ "group" ]
permissions = args[ "permissions" ]
result = self.__parsePermissions( name , permissions )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
permissions = result[ "Value" ]
data = dict()
for key , value in request.params.items():
try:
if len( value ) > 0:
data[ key ] = str( value )
except:
pass
if not len( data ) > 0:
err = "Data to store has zero length"
gLogger.error( "Result %s: %s" % ( msg , err ) )
return { "success" : "false" , "error" : err }
for i in LOAD_LAYOUT_ARGS : # Add vital params to layout if they are absent
if not data.has_key( i ):
data[ i ] = args[ i ]
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.storeVar( name , data , permissions )
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
result = self.__setHistory( args , "Save" )
history = dict()
if not result[ "OK" ]:
history[ "Save" ] = result[ "Message" ]
else:
history[ "Save" ] = result[ "Value" ]
gLogger.info( "Result %s: %s AND %s" % ( msg , data , history ) )
return { "success" : "true" , "result" : data , "history" : history }
def __getSelectionData(self):
callback = {}
lhcbGroup = credentials.getSelectedGroup()
lhcbUser = str(credentials.getUsername())
if len(request.params) > 0:
tmp = {}
for i in request.params:
tmp[i] = str(request.params[i])
callback["extra"] = tmp
RPC = getRPCClient("WorkloadManagement/WMSAdministrator")
result = RPC.getSiteMaskSummary()
gLogger.info("\033[0;31m ++ R ++ \033[0m", result)
if result["OK"]:
response = []
tier1 = list([
"LCG.CERN.ch", "LCG.CNAF.it", "LCG.GRIDKA.de", "LCG.IN2P3.fr",
"LCG.NIKHEF.nl", "LCG.PIC.es", "LCG.RAL.uk", "LCG.SARA.nl"
])
if len(result["Value"]) > 0:
site = result["Value"]
# gLogger.info("=====",initSite)
# for key in sorted(initSite.iterkeys()):
# keys = initSite.keys()
# keys.sort()
# site = map(initSite.get, keys)
# gLogger.info("+++++",site)
for i in tier1:
if site.has_key(i):
countryCode = i.rsplit(".", 1)[1]
response.append(
[str(i), str(countryCode),
str(site[i])])
del site[i]
for key in sorted(site.iterkeys()):
countryCode = key.rsplit(".", 1)[1]
response.append(
[str(key), str(countryCode),
str(site[key])])
else:
response = [["Nothing to display"]]
else:
response = [["Error during RPC call"]]
callback["siteName"] = response
###
return callback
def __saveLayout(self):
gLogger.info("Running saveLayout()")
msg = "saveLayout() for %s@%s" % (getUsername(), getSelectedGroup())
result = self.__params2string(SAVE_LAYOUT_ARGS)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
args = result["Value"]
name = args["name"]
user = args["user"]
group = args["group"]
permissions = args["permissions"]
result = self.__parsePermissions(name, permissions)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
permissions = result["Value"]
data = dict()
for key, value in request.params.items():
try:
if len(value) > 0:
data[key] = str(value)
except:
pass
if not len(data) > 0:
err = "Data to store has zero length"
gLogger.error("Result %s: %s" % (msg, err))
return {"success": "false", "error": err}
for i in LOAD_LAYOUT_ARGS: # Add vital params to layout if they are absent
if not data.has_key(i):
data[i] = args[i]
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.storeVar(name, data, permissions)
gLogger.debug(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
result = self.__setHistory(args, "Save")
history = dict()
if not result["OK"]:
history["Save"] = result["Message"]
else:
history["Save"] = result["Value"]
gLogger.info("Result %s: %s AND %s" % (msg, data, history))
return {"success": "true", "result": data, "history": history}
def htmlUserInfo():
username = credentials.getUsername()
if not username or username == "anonymous":
htmlData = "Anonymous"
else:
selectedGroup = credentials.getSelectedGroup()
availableGroups = [ ( groupName, diracURL( controller = 'web/userdata', action = 'changeGroup', id = groupName ) ) for groupName in credentials.getAvailableGroups() ]
htmlData = "%s@%s" % ( username, yuiWidgets.dropDownMenu( "UserGroupPos", selectedGroup, availableGroups ) )
dn = credentials.getUserDN()
if dn:
htmlData += " (%s)" % dn
else:
if 'REQUEST_URI' in request.environ:
uri = str( request.environ[ 'REQUEST_URI' ] )
else:
uri = ""
htmlData += " (<a href='https://%s%s'>certificate login</a>)" % ( str( request.environ[ 'HTTP_HOST' ] ), uri )
return htmlData
def display(self):
checkUserCredentials()
dn = getUserDN()
user = getUsername()
group = getSelectedGroup()
gLogger.always( "User: %s, Group: %s, DN: %s" % ( user , group , dn ) )
templates = [ "reg_%s.mako" % i for i in [ "done" , "form" , "info" ] ]
html = [ "reg_%s.html" % i for i in [ "footer" , "header" , "conditions" , "form" , "done" ] ]
files = templates + html
basedir = os.path.join( rootPath , "Web" , "dirac" , "templates" )
for i in files:
f = os.path.join( basedir , i )
if not os.path.exists( f ):
gLogger.error( "File does not exists: %s" % f )
return render( "web/External.mako" )
if dn and user == "anonymous":
upc = UserProfileClient( "Registration" , getRPCClient )
result = upc.retrieveVar( dn )
if result[ "OK" ]:
c.sent = result[ "Value" ]
return render( "/reg_done.mako" )
else:
return render("/reg_form.mako")
if not dn or dn == "":
return render("/reg_info.mako")
if "site" not in request.params:
c.select = gConfig.getValue( "/Website/DefaultExternalURL", "http://diracgrid.org" )
return render( "web/External.mako" )
# No idea what this code should do...
if request.params.has_key( "site" ) and len( request.params[ "site" ] ) > 0:
if str( request.params[ "site" ] ) != "All":
c.select = str( request.params[ "site" ] )
gLogger.debug("Request's body:")
for key in request.params.keys():
if not key == "site" and len(request.params[key]) > 0:
c.select = c.select + "&" + key + "=" + request.params[key]
try:
gLogger.debug("%s - %s" % (key,request.params[key]))
except Exception,x:
gLogger.error("Exception: %s" % str(x))
pass
def __deleteHistory( self , name , state ):
"""
Deleting item from Load and Save history list
Return resulting list
"name" is a string
"state" can be either "Save" or "Load"
"""
gLogger.info( "Running deleteHistory( %s )" % name )
msg = "deleteHistory() for %s@%s" % ( getUsername() , getSelectedGroup() )
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions( opt , 5 )
upc = UserProfileClient( "Default" , getRPCClient )
group = str( getSelectedGroup() )
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar( profile_name )
gLogger.info( result )
if not result[ "OK" ]:
if result[ "Message" ].find( "No data" ) < 0 :
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
gLogger.info( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_OK( list() ) # Nothing to delete, return an empty list
else:
result = result[ "Value" ]
if not isinstance( result , list ):
err = "List expected at: %s" % profile_name
gLogger.error( "Result %s: %s" % ( msg , err ) )
return S_ERROR( err )
history = list()
for i in result:
if i.has_key( "name" ) and not i["name"] == name:
history.append( i )
if( len( history ) > history_length ):
history = result[ history_length ]
gLogger.error( "History: %s" % history )
result = upc.storeVar( profile_name , history )
gLogger.info( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return S_ERROR( result[ "Message" ] )
gLogger.info( "Result %s: %s" % ( msg , history ) )
return S_OK( history )
def __refresh(self, forceRefresh=False):
userName = credentials.getUsername()
if not forceRefresh and userName in self.__userTimestamp:
if time.time() - self.__userTimestamp[userName] > self.__cacheTime:
return
gLogger.info("Connecting to retrieve notification stats for user %s" %
userName)
ntf = self.getNtfClient()
result = ntf.getNotifications({}, [], 0, 0)
if not result['OK']:
gLogger.error("Could not retrieve notifications",
"for user %s: %s" % (userName, result['Message']))
self.__stats[userName] = {'totalNots': 0}
self.__userTimestamp[userName] = time.time()
self.__notifications[userName] = []
return
nots = result['Value']
self.__notifications[userName] = nots
total = len(nots['Records'])
new = []
records = []
if total:
for row in nots['Records']:
rD = {}
for i in range(len(nots['ParameterNames'])):
param = nots['ParameterNames'][i]
if param == 'timestamp':
rD[param] = row[i].strftime("%Y/%m/%d %H:%M:%S UTC")
else:
rD[param] = row[i]
records.append(rD)
new = []
for record in records:
if not record['seen']:
new.append(record['id'])
new.sort()
stats = {'totalNots': total, 'newNots': new}
gLogger.info("user %s has %s/%s notifications" %
(userName, total, len(new)))
self.__stats[userName] = stats
self.__userTimestamp[userName] = time.time()
self.__notifications[userName] = records
def __deleteHistory(self, name, state):
"""
Deleting item from Load and Save history list
Return resulting list
"name" is a string
"state" can be either "Save" or "Load"
"""
gLogger.info("Running deleteHistory( %s )" % name)
msg = "deleteHistory() for %s@%s" % (getUsername(), getSelectedGroup())
opt = "/Website/" + USER_PROFILE_NAME + "/ShowHistory"
history_length = gConfig.getOptions(opt, 5)
upc = UserProfileClient("Default", getRPCClient)
group = str(getSelectedGroup())
profile_name = USER_PROFILE_NAME + ".History." + state + "." + group
result = upc.retrieveVar(profile_name)
gLogger.info(result)
if not result["OK"]:
if result["Message"].find("No data") < 0:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
gLogger.info("Result %s: %s" % (msg, result["Message"]))
return S_OK(list()) # Nothing to delete, return an empty list
else:
result = result["Value"]
if not isinstance(result, list):
err = "List expected at: %s" % profile_name
gLogger.error("Result %s: %s" % (msg, err))
return S_ERROR(err)
history = list()
for i in result:
if i.has_key("name") and not i["name"] == name:
history.append(i)
if (len(history) > history_length):
history = result[history_length]
gLogger.error("History: %s" % history)
result = upc.storeVar(profile_name, history)
gLogger.info(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return S_ERROR(result["Message"])
gLogger.info("Result %s: %s" % (msg, history))
return S_OK(history)
def __getLayout( self ) :
gLogger.info( "Running getLayout()" )
msg = "getLayout() for %s@%s" % ( getUsername() , getSelectedGroup() )
upc = UserProfileClient( USER_PROFILE_NAME, getRPCClient )
result = upc.listAvailableVars()
gLogger.debug( result )
if not result[ "OK" ]:
gLogger.error( "Result %s: %s" % ( msg , result[ "Message" ] ) )
return { "success" : "false" , "error" : result[ "Message" ] }
result = result[ "Value" ]
gLogger.always( "array2obj" )
availble = map( self.__array2obj , result )
gLogger.always( availble )
users = list()
for i in result :
if len( i ) > 1 :
users.append( { "user" : i[ 0 ] } )
users = uniqueElements( users )
gLogger.info( "Result %s: %s AND %s" % ( msg , availble , users ) )
return { "success" : "true" , "result" : availble , "users" : users }
def __getLayout(self):
gLogger.info("Running getLayout()")
msg = "getLayout() for %s@%s" % (getUsername(), getSelectedGroup())
upc = UserProfileClient(USER_PROFILE_NAME, getRPCClient)
result = upc.listAvailableVars()
gLogger.debug(result)
if not result["OK"]:
gLogger.error("Result %s: %s" % (msg, result["Message"]))
return {"success": "false", "error": result["Message"]}
result = result["Value"]
gLogger.always("array2obj")
availble = map(self.__array2obj, result)
gLogger.always(availble)
users = list()
for i in result:
if len(i) > 1:
users.append({"user": i[0]})
users = uniqueElements(users)
gLogger.info("Result %s: %s AND %s" % (msg, availble, users))
return {"success": "true", "result": availble, "users": users}
def getRequesterEmail(self):
"""
"""
user = getUsername()
if not user:
gLogger.debug("user value is empty")
return None
if user == "anonymous":
gLogger.debug("user is anonymous")
return None
email = gConfig.getValue("/Registry/Users/%s/Email" % user, "")
gLogger.debug("/Registry/Users/%s/Email - '%s'" % (user, email))
emil = email.strip()
if not email:
return None
return email
