def getModelServers():
resultServers = []
pQuery = PBSQuery()
try:
servers = pQuery.get_serverinfo()
for serverName, pbsServer in servers.items():
customServer = PBSServer(name=serverName)
try:
customServer.state = TorqueService._listToStr(pbsServer[pbs.ATTR_status], '|')
except KeyError:
pass
try:
customServer.total_jobs = TorqueService._listToInt(pbsServer[pbs.ATTR_total])
except KeyError:
pass
try:
customServer.running_jobs = int(TorqueService._strToDict(pbsServer[pbs.ATTR_count][0])['Running'])
except KeyError:
pass
try:
customServer.queued_jobs = int(TorqueService._strToDict(pbsServer[pbs.ATTR_count][0])['Queued'])
except KeyError:
pass
try:
customServer.pbs_version = TorqueService._listToStr(pbsServer[pbs.ATTR_pbsversion], '|')
except KeyError:
pass
resultServers.append(customServer)
except PBSError as pbsErr:
print(pbsErr)
return resultServers
def main():
pq = PBSQuery()
print 'Server:',pq.server
serverinfo = pq.get_serverinfo()
for k, v in sorted(serverinfo.iteritems()):
print k
for i, j in sorted(v.iteritems()):
print i, j
def __init__(self, server_name):
p = PBSQuery(str(server_name))
info = p.get_serverinfo().items()[0]
self.name = info[0]
self.p = p
for k, v in info[1].items():
if k.startswith('resources'):
for i, j in v.items():
setattr(self, k + '_' + i, j[0])
else:
setattr(self, k, v[0])
def __init__(self, server_name):
p = PBSQuery(str(server_name))
info = p.get_serverinfo().items()[0]
self.name = info[0]
self.p = p
for k,v in info[1].items():
if k.startswith('resources'):
for i,j in v.items():
setattr(self, k + '_' + i, j[0])
else:
setattr(self, k, v[0])
def __init__(self, server, verbosity=0, diagOutputFile=None):
self.SRList = {}
self.activeNodes = {}
self.verbosity = verbosity
self.server = server
# Load Torque configuration
try:
torqueConfig=PBSQuery(server)
self.server_info=torqueConfig.get_serverinfo()[server]
self.nodes=torqueConfig.getnodes()
self.queues=torqueConfig.getqueues()
except PBSError, e:
self.__debug(0,"Error connecting to PBS server: %s" % e)
sys.exit(1)
def __init__(self, server, verbosity=0, diagOutputFile=None):
self.SRList = {}
self.activeNodes = {}
self.verbosity = verbosity
self.server = server
# Load Torque configuration
try:
torqueConfig=PBSQuery(server)
self.server_info=torqueConfig.get_serverinfo()[server]
self.nodes=torqueConfig.getnodes()
self.queues=torqueConfig.getqueues()
except PBSError, e:
self.__debug(0,"Error connecting to PBS server: %s" % e)
sys.exit(1)
class QstatViewer:
"""
Presents a nicer (?) interface to PBSQuery
The two main member objects are:
* jobs -- a dictionary with job ID (as str) as the key,
and the corresponding Job object as the value
* nodes -- a dictionary with node name as the key,
and a set of corresponding job IDs (of jobs
running on node)
"""
def __init__(self, pbs_server=None, debug_p=False):
"""Creates a QstatViewer object. Arguments:
- pbs_server : FQDN of the TORQUE server to query (string)"""
self.debug_p = debug_p
self.nodes = {}
self.jobs = {}
self.queues = {}
self.pbsquery = PBSQuery(pbs_server)
self.servername = self.pbsquery.get_server_name()
self.__make_server()
self.__make_queues()
self.__make_jobs()
self.__make_nodes()
def __make_nodes(self):
"""Make dict with node names as keys, and list of job objects as values"""
# make list of jobids running on the node
#node_jobs = {}
#for jobid,job in self.jobs.iteritems():
# if job.exec_host:
# for node_cpu in job.exec_host:
# node = node_cpu.split('/')[0]
# if node not in node_jobs:
# node_jobs[node] = []
# else:
# node_jobs[node].append(jobid)
rawnodes = self.pbsquery.getnodes()
for n,s in rawnodes.iteritems():
self.nodes[n] = Node(name=n, pbsnodes_dict=dict(s), debug_p=self.debug_p)
def __make_jobs(self):
"""Make dict with job IDs as keys, and job properties as values"""
rawjobs = self.pbsquery.getjobs()
for j,p in rawjobs.iteritems():
self.jobs[j] = Job(id=j, pbsjobs_dict=dict(p), debug_p=self.debug_p)
def __make_queues(self):
"""make dict with queue names as keys, and queue properties as values"""
rawqueues = self.pbsquery.getqueues()
for q,p in rawqueues.iteritems():
self.queues[q] = Queue(name=q, pbsqueue_dict=p)
def __make_server(self):
self.__serverinfo = self.pbsquery.get_serverinfo()[self.servername]
if self.debug_p:
print 'FOOBAR: self.serverinfo =', self.__serverinfo
for k,v in self.__serverinfo.iteritems():
self.__dict__[k] = None
if k == 'state_count':
# Example of state_count: Transit:0 Queued:-6458 Held:6383 Waiting:0 Running:964 Exiting:0
self.__dict__[k] = {}
vals = v[0].strip().split(' ')
for state in vals:
statename = state.split(':')[0]
stateval = int(state.split(':')[1])
self.__dict__[k][statename] = stateval
elif k == 'resources_default':
v['mem'] = Memory(v['mem'][0])
v['pmem'] = Memory(v['pmem'][0])
v['cput'] = pbstimestr_to_timedelta(v['cput'][0])
v['walltime'] = pbstimestr_to_timedelta(v['walltime'][0])
self.__dict__[k] = v
elif k == 'resources_assigned':
if 'mem' in v:
v['mem'] = Memory(v['mem'][0])
if 'vmem' in v:
v['vmem'] = Memory(v['vmem'][0])
if 'ncpus' in v:
v['ncpus'] = int(v['ncpus'][0])
if 'nodect' in v:
v['nodect'] = int(v['nodect'][0])
self.__dict__[k] = v
elif k == 'scheduling' or k == 'query_other_jobs':
if v[0] == 'True':
v[0] = True
elif v[0] == 'False':
v[0] = False
self.__dict__[k] = v[0]
elif k == 'scheduler_iteration':
self.__dict__[k] = datetime.timedelta(seconds=int(v[0]))
elif k == 'next_job_number' or k == 'node_check_rate' or k == 'tcp_timeout' or k == 'total_jobs':
self.__dict__[k] = int(v[0])
elif len(v) == 1:
self.__dict__[k] = v[0]
else:
self.__dict__[k] = v
def get_job(self, jobid):
"""Queries the queue for jobid"""
j = self.pbsquery.getjob(jobid)
if self.debug_p:
print 'ALOHA: ',
print j.__dict__['data']
if 'data' in j.__dict__:
return Job(id=jobid, pbsjobs_dict=dict(j), debug_p=self.debug_p)
else:
return None
def jobs_by_user(self, username=None):
"""Returns a dict of jobs (keyed by jobid) belonging to username"""
retval = {}
if not username:
retval = None
else:
for jobid,job in self.jobs.iteritems():
if job.owner == username:
retval[jobid] = job
return retval
def nodes_with_property(self, prop):
"""Returns a dict of nodes (keyed by nodename) having the given property string"""
retval = {}
if prop:
for nodename,node in self.nodes.iteritems():
if prop in node.properties:
retval[nodename] = node
else:
retval = self.nodes
return retval
def nodes_in_clan(self, clan):
"""Returns a dict of nodes (keyed by nodename) belonging to the given clan"""
retval = {}
if clan:
for nodename,node in self.nodes.iteritems():
if clan == node.clan:
retval[nodename] = node
else:
retval = self.nodes
return retval
def __unicode__(self):
if self.debug_p:
print 'FOOBAR: type(self.jobs) =', type(self.jobs)
print 'FOOBAR: self.jobs =', self.jobs
job_dict_list = []
for k,v in self.jobs.iteritems():
job_dict_list.append(str(v))
return str(job_dict_list)
def __str__(self):
return self.__unicode__()
#!/usr/bin/python
from PBSQuery import PBSQuery, PBSError
server = 'grid63.lal.in2p3.fr'
try:
p=PBSQuery(server)
pbs=p.get_serverinfo()
nodes=p.getnodes()
jobs=p.getjobs()
queues=p.getqueues()
except PBSError, e:
print "<h3>Error connecting to PBS server:</h3><tt>",e,"</tt>"
sys.exit(1)
print ""
print "Server info:"
print pbs
print ""
print "Nodes:"
for node in nodes.keys():
print "********** %s *********" % node
print nodes[node]
print ""
print "Jobs:"
for job in jobs.keys():
print "********** Job %s *********" % job
print jobs[job]
self.resources_default[res] = pbstimestr_to_timedelta(self.resources_default[res][0])
def __str__(self):
outlist = ['Server: {0}'.format(self.name), '\n',
' ACL hosts: {0}'.format(self.acl_hosts), '\n',
' Scheduling: {0}'.format(self.scheduling), '\n',
' Managers: {0}'.format(self.managers), '\n',
" Auth'd users: {0}".format(self.authorized_users), '\n',
' Submit hosts: {0}'.format(self.submit_hosts), '\n',
' Next job no.: {0}'.format(self.next_job_number), '\n',
' Log events: {0}'.format(self.log_events), '\n',
' Mail from: {0}'.format(self.mail_from), '\n',
' Query other jobs: {0}'.format(self.query_other_jobs), '\n',
' Resources default: {0}'.format(self.resources_default), '\n',
' Scheduler iteration: {0}'.format(self.scheduler_iteration), '\n',
' Node check rate: {0}'.format(self.node_check_rate), '\n',
' TCP timeout: {0}'.format(self.tcp_timeout), '\n',
]
retstr = "".join(outlist)
return retstr
if __name__ == '__main__':
pq = PBSQuery()
server = Server(name=pq.server, pbsserver_dict=pq.get_serverinfo())
print server
