def reschedule(backend_task_id, job_status, sub_ids, backend_ids):
taskClient = TaskClient()
jobManager = RPCClient('WorkloadManagement/JobManager')
if job_status:
result = taskClient.rescheduleTask(backend_task_id, job_status)
return result
elif sub_ids:
#jsub would match sub_ids with backend_ids to avoid executing codes here.
pass
elif backend_ids:
result = jobManager.rescheduleJob(backend_ids)
return result
return {'OK': True, 'Value': []}
def web_getTaskJobInfo(self):
taskClient = TaskClient()
jobID = int(self.request.arguments["JobID"][0])
outFields = ['Info']
result = yield self.threadTask(taskClient.getJobs, [jobID], outFields)
if not (result["OK"] and result['Value']):
self.finish({
"success": "false",
"result": '',
"error": result["Message"]
})
return
info = json.loads(result['Value'][0][0])
allInfo = []
for name, value in sorted(info.iteritems(), key=lambda d: d[0]):
if type(value) == type([]):
value = ', '.join(value)
allInfo.append([name, str(value)])
callback = {"success": "true", "result": allInfo}
self.finish(callback)
def web_getTaskData(self):
taskClient = TaskClient()
req = self.__request()
condDict = req
limit = self.numberOfJobs
offset = self.pageNumber
orderAttribute = self.globalSort[0][0] + ':' + self.globalSort[0][1]
result = yield self.threadTask(taskClient.getTaskCount, condDict)
if not result["OK"]:
self.finish({
"success": "false",
"result": [],
"total": 0,
"error": result["Message"]
})
return
total = result['Value']
result = yield self.threadTask(taskClient.listTask, condDict, limit,
offset, orderAttribute)
if not result["OK"]:
self.finish({
"success": "false",
"result": [],
"total": 0,
"error": result["Message"]
})
return
fields = [
'TaskID', 'TaskName', 'Status', 'Owner', 'OwnerGroup', 'OwnerDN',
'Site', 'JobGroup'
]
values = []
for data in result['Value']:
value = {}
for d in data:
if d in fields:
value[d] = data[d]
value['IconStatus'] = STATUS_ICON_MAP[data['Status']]
value['CreationTime'] = str(data['CreationTime'])
value['UpdateTime'] = str(data['UpdateTime'])
value['Progress'] = data['Progress']
totalJobs = data['Progress'].get('Total', 0)
deletedJobs = data['Progress'].get('Deleted', 0)
value['Total'] = '%s/%s' % (totalJobs - deletedJobs, totalJobs)
values.append(value)
callback = {
"success": "true",
"result": values,
"total": total,
"date": None
}
self.finish(callback)
def web_getSelectionData(self):
sData = self.getSessionData()
taskClient = TaskClient()
callback = {}
user = sData["user"]["username"]
group = sData["user"]["group"]
if user == "Anonymous":
callback["status"] = [["Insufficient rights"]]
elif 'JobAdministrator' in sData['user']['properties']:
callback["status"] = [['Init'], ['Ready'], ['Processing'],
['Finished'], ['Expired'], ['Removed']]
elif 'NormalUser' in sData['user']['properties']:
callback["status"] = [['Init'], ['Ready'], ['Processing'],
['Finished'], ['Expired']]
if user == "Anonymous":
callback["owner"] = [["Insufficient rights"]]
elif 'NormalUser' in sData['user']['properties']:
owner = [[user]]
else:
result = yield self.threadTask(taskClient.getTaskOwners)
if result["OK"]:
owner = []
if len(result["Value"]) > 0:
for i in result["Value"]:
owner.append([str(i)])
else:
owner = [["Nothing to display"]]
else:
gLogger.error("getTaskOwners() return error: %s" %
result["Message"])
owner = [["Error happened on service side"]]
callback["owner"] = owner
if user == "Anonymous":
callback["ownerGroup"] = [["Insufficient rights"]]
elif 'NormalUser' in sData['user']['properties']:
ownerGroup = [[group]]
else:
result = yield self.threadTask(taskClient.getTaskOwnerGroups)
if result["OK"]:
ownerGroup = []
if len(result["Value"]) > 0:
for i in result["Value"]:
ownerGroup.append([str(i)])
else:
ownerGroup = [["Nothing to display"]]
else:
gLogger.error("getTaskOwnerGroups() return error: %s" %
result["Message"])
ownerGroup = [["Error happened on service side"]]
callback["ownerGroup"] = ownerGroup
self.finish(callback)
def status(backend_task_id, job_status):
taskClient = TaskClient()
jobMonitor = RPCClient('WorkloadManagement/JobMonitoring')
if not job_status:
result = taskClient.getTaskProgress(backend_task_id)
if 'Value' in result:
result['njobs'] = result['Value']
return result
else:
jobs = taskClient.getTaskJobs(backend_task_id)['Value']
job_list = {status: [] for status in job_status}
for job in jobs:
try:
status = jobMonitor.getJobStatus(int(job))['Value']
if status in job_status:
job_list[status].append(int(job))
except:
pass
return {'OK': True, 'jobIDs': job_list}
def web_getTaskJobsStatistics(self):
taskClient = TaskClient()
taskID = int(self.request.arguments["TaskID"][0])
statistics = []
statistics.append(['==== Status ====', ''])
result = yield self.threadTask(taskClient.getTaskJobsStatistics,
taskID, 'Status')
if result["OK"]:
for s in result['Value']:
statistics.append([s, result['Value'].get(s, 0)])
statistics.append(['', ''])
statistics.append(['==== Minor Status ====', ''])
result = yield self.threadTask(taskClient.getTaskJobsStatistics,
taskID, 'MinorStatus')
if result["OK"]:
for s in result['Value']:
statistics.append([s, result['Value'].get(s, 0)])
statistics.append(['', ''])
statistics.append(['==== Application Status ====', ''])
result = yield self.threadTask(taskClient.getTaskJobsStatistics,
taskID, 'ApplicationStatus')
if result["OK"]:
for s in result['Value']:
statistics.append([s, result['Value'].get(s, 0)])
statistics.append(['', ''])
statistics.append(['==== Site ====', ''])
result = yield self.threadTask(taskClient.getTaskJobsStatistics,
taskID, 'Site')
if result["OK"]:
for s in result['Value']:
statistics.append([s, result['Value'].get(s, 0)])
statistics.append(['', ''])
statistics.append(['==== Job Group ====', ''])
result = yield self.threadTask(taskClient.getTaskJobsStatistics,
taskID, 'JobGroup')
if result["OK"]:
for s in result['Value']:
statistics.append([s, result['Value'].get(s, 0)])
callback = {"success": "true", "result": statistics}
self.finish(callback)
def web_getTaskJobs(self):
taskClient = TaskClient()
taskID = int(self.request.arguments["TaskID"][0])
result = yield self.threadTask(taskClient.getTaskJobs, taskID)
if not result["OK"]:
self.finish({
"success": "false",
"result": '',
"error": result["Message"]
})
return
callback = {"success": "true", "result": result['Value']}
self.finish(callback)
def web_renameTask(self):
taskClient = TaskClient()
taskID = int(self.request.arguments["TaskID"][0])
newName = self.request.arguments["NewName"][0]
result = yield self.threadTask(taskClient.renameTask, taskID, newName)
if not result["OK"]:
self.finish({
"success": "false",
"result": '',
"error": result["Message"]
})
return
callback = {"success": "true", "result": result['Value']}
self.finish(callback)
def web_deleteTask(self):
taskClient = TaskClient()
taskIDs = self.request.arguments["TaskID"][0].split(',')
if '' in taskIDs:
taskIDs.remove('')
taskIDs = [int(taskID) for taskID in taskIDs]
for taskID in taskIDs:
result = yield self.threadTask(taskClient.deleteTask, taskID)
if not result["OK"]:
self.finish({
"success": "false",
"result": '',
"error": result["Message"]
})
return
callback = {"success": "true", "result": taskIDs}
self.finish(callback)
def web_getTaskHistory(self):
taskClient = TaskClient()
taskID = int(self.request.arguments["TaskID"][0])
result = yield self.threadTask(taskClient.getTaskHistories, taskID)
if not result["OK"]:
self.finish({
"success": "false",
"result": '',
"error": result["Message"]
})
return
histories = []
for status, statusTime, description in result['Value']:
histories.append([status, str(statusTime), description])
callback = {"success": "true", "result": histories}
self.finish(callback)
def web_getTaskProgress(self):
taskClient = TaskClient()
taskID = int(self.request.arguments["TaskID"][0])
result = yield self.threadTask(taskClient.getTaskProgress, taskID)
if not result["OK"]:
self.finish({
"success": "false",
"result": '',
"error": result["Message"]
})
return
statuses = ['Total', 'Done', 'Failed', 'Running', 'Waiting', 'Deleted']
allProgress = []
for status in statuses:
allProgress.append([status, result['Value'].get(status, 0)])
callback = {"success": "true", "result": allProgress}
self.finish(callback)
def web_getTaskInfo(self):
taskClient = TaskClient()
taskID = int(self.request.arguments["TaskID"][0])
result = yield self.threadTask(taskClient.getTaskInfo, taskID)
if not result["OK"]:
self.finish({
"success": "false",
"result": '',
"error": result["Message"]
})
return
allInfo = []
for name, value in sorted(result['Value'].iteritems(),
key=lambda d: d[0]):
if type(value) == type([]):
value = ', '.join(value)
allInfo.append([name, str(value)])
callback = {"success": "true", "result": allInfo}
self.finish(callback)
def web_getTaskJobList(self):
taskClient = TaskClient()
taskID = int(self.request.arguments["TaskID"][0])
result = yield self.threadTask(taskClient.getTaskJobs, taskID)
if not result["OK"]:
self.finish({
"success": "false",
"result": '',
"error": result["Message"]
})
return
jobIDs = result['Value']
RPC = RPCClient("WorkloadManagement/JobMonitoring")
result = RPC.getJobsStatus(result['Value'])
if not result["OK"]:
self.finish({
"success": "false",
"result": '',
"error": result["Message"]
})
return
jobStatuses = result['Value']
jobList = []
for jobID in jobIDs:
if jobID in jobStatuses:
jobList.append([jobID, jobStatuses[jobID]['Status']])
else:
jobList.append([jobID, 'Deleted'])
callback = {"success": "true", "result": jobList}
self.finish(callback)
)
Script.registerSwitch("w", "whole", "List all the fields")
Script.registerSwitch("l:", "limit=", "Task number limit")
Script.registerSwitch("e", "expired", "Include expired tasks")
Script.registerSwitch("r", "removed", "Include removed tasks (only for admin)")
Script.registerSwitch("u", "users",
"Include other users' tasks (only for admin)")
Script.registerSwitch("a", "all", "Show all tasks")
Script.parseCommandLine(ignoreErrors=False)
options = Script.getUnprocessedSwitches()
args = Script.getPositionalArgs()
from DIRAC.Core.Security.ProxyInfo import getProxyInfo
from IHEPDIRAC.WorkloadManagementSystem.Client.TaskClient import TaskClient
taskClient = TaskClient()
fieldTitle = {
'TaskID': 'TaskID',
'TaskName': 'TaskName',
'Status': 'Status',
'Owner': 'Owner',
'OwnerDN': 'OwnerDN',
'OwnerGroup': 'OwnerGroup',
'CreationTime': 'CreationTime',
'UpdateTime': 'UpdateTime',
'Progress': 'Progress(T/(D|F|R|W|O))',
'Site': 'Site',
'JobGroup': 'JobGroup',
}
def delete(backend_task_id, job_status):
taskClient = TaskClient()
result = taskClient.deleteTask(backend_task_id, job_status)
return result