Changeset 139


Ignore:
Timestamp:
10/18/06 11:19:04 (18 years ago)
Author:
bas
Message:

src/PBSQuery.py:

  • rewrite/indent
  • Make use of UserDict?, removed a lot of code
  • Still a lot of debug code ;-)
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/PBSQuery.py

    r137 r139  
    6060"""
    6161import pbs
     62import UserDict
     63import sys
    6264
    6365class PBSError(Exception):
    64         def __init__(self, msg=''):
    65                 self.msg = msg
    66                 Exception.__init__(self, msg)
    67         def __repr__(self):
    68                 return self.msg
    69         __str__ = __repr__
     66        def __init__(self, msg=''):
     67                self.msg = msg
     68                Exception.__init__(self, msg)
     69               
     70        def __repr__(self):
     71                return self.msg
     72
     73        __str__ = __repr__
    7074
    7175
    7276class PBSQuery:
    73     def __init__(self, server=None):
    74         if not server:
    75             self.server = pbs.pbs_default()
    76         else:
    77             self.server = server
    78 
    79 
    80     def _connect(self):
    81        """Connect to the PBS/Torque server"""
    82        self.con = pbs.pbs_connect(self.server)
    83        if self.con < 0:
    84           str = "Could not make an connection with %s\n" %(self.server)
    85           raise PBSError(str)
    86 
    87     def _disconnect(self):
    88        """Close the PBS/Torque connection"""
    89        pbs.pbs_disconnect(self.con)
    90        self.attribs = 'NULL'
    91 
    92     def _list_2_attrib(self, list):
    93         """Convert an python list to an attrib list suitable for pbs"""
    94         self.attribs = pbs.new_attrl( len(list) )
    95         i = 0
    96         for attrib in list:
    97             self.attribs[i].name = attrib
    98             i = i + 1
    99 
    100     def _pbsstr_2_list(self, str, delimiter):
    101         """Convert an string to an python list and use delimiter as spit char"""
    102         l = sting.splitfields(str, delimiter)
    103         if len(l) > 1:
    104            return l
    105 
    106     def _list_2_dict(self, l, class_func):
    107         """Convert an pbsstat function list to an class dictionary"""
    108         self.d = {}
    109         for item in l:
    110             new = class_func()
    111             for a in item.attribs:
    112                 new.name = item.name
    113                 if a.resource:
    114                    new.attribs[a.name + '.' + a.resource] = a.value
    115                 else:
    116                    new.attribs[a.name] = a.value
    117                 self.d[item.name] = new
    118         self._free(l)
     77        def __init__(self, server=None):
     78                if not server:
     79                        self.server = pbs.pbs_default()
     80                else:
     81                        self.server = server
     82
     83
     84        def _connect(self):
     85                """Connect to the PBS/Torque server"""
     86                self.con = pbs.pbs_connect(self.server)
     87                if self.con < 0:
     88                        str = "Could not make an connection with %s\n" %(self.server)
     89                        raise PBSError(str)
     90
     91        def _disconnect(self):
     92                """Close the PBS/Torque connection"""
     93                pbs.pbs_disconnect(self.con)
     94                self.attribs = 'NULL'
     95
     96        def _list_2_attrib(self, list):
     97                """Convert an python list to an attrib list suitable for pbs"""
     98                self.attribs = pbs.new_attrl( len(list) )
     99                i = 0
     100                for attrib in list:
     101                        self.attribs[i].name = attrib
     102                        i = i + 1
     103
     104        def _pbsstr_2_list(self, str, delimiter):
     105                """Convert an string to an python list and use delimiter as spit char"""
     106                l = sting.splitfields(str, delimiter)
     107                if len(l) > 1:
     108                        return l
     109
     110        def _list_2_dict(self, l, class_func):
     111                """Convert an pbsstat function list to an class dictionary"""
     112                self.d = {}
     113                for item in l:
     114                        new = class_func()
     115                        self.d[item.name] = new
     116                       
     117                        for a in item.attribs:
     118                                new.name = item.name
     119                                if a.resource:
     120                                        #new.attribs[a.name + '.' + a.resource] = a.value
     121                                        new[a.name + '.' + a.resource] = a.value
     122                                else:
     123                                        #new.attribs[a.name] = a.value
     124                                        new[a.name] = a.value
     125
     126                #print new
     127                print 'Basje'
     128                print self.d['q_express'].has_key('resources_max.walltime')
     129                #print 'items ', new.items()
     130                q_attr =  self.d['q_express']
     131                print 'q_attr: ', type(q_attr)
     132                print 'q_attr class: ', q_attr.__class__
     133                print 'has_key', q_attr.has_key('resources_max.walltime')
     134                self._free(l)
    119135               
    120     def _free(self, memory):
    121         pbs.pbs_statfree(memory)
    122 
    123     def _statserver(self, attrib_list=None):
    124         """Get the server config from the pbs server"""
    125         if attrib_list:
    126            self._list_2_attrib(attrib_list)
    127         else:
    128            self.attribs = 'NULL'
    129 
    130         self._connect()
    131         serverinfo = pbs.pbs_statserver(self.con, self.attribs, 'NULL')
    132         self._disconnect()
    133 
    134         self.serverinfo = {}
    135         self._list_2_dict(serverinfo, server)
    136 
    137     def get_serverinfo(self, attrib_list=None):
    138         self._statserver(attrib_list)
    139         return self.d
    140 
    141     def _statqueue(self, queue_name='', attrib_list=None):
    142         """Get the queue config from the pbs server"""
    143         if attrib_list:
    144            self._list_2_attrib(attrib_list)
    145         else:
    146            self.attribs = 'NULL'
    147 
    148         self._connect()
    149         queues = pbs.pbs_statque(self.con, queue_name, self.attribs, 'NULL')
    150         self._disconnect()
    151 
    152         self.queues = {}
    153         self._list_2_dict(queues, queue)
    154 
    155     def getqueue(self, name, attrib_list=None):
    156         self._statqueue(name, attrib_list)
    157         return self.d
     136        def _free(self, memory):
     137                pbs.pbs_statfree(memory)
     138
     139        def _statserver(self, attrib_list=None):
     140                """Get the server config from the pbs server"""
     141                if attrib_list:
     142                        self._list_2_attrib(attrib_list)
     143                else:
     144                        self.attribs = 'NULL'
     145                       
     146                self._connect()
     147                serverinfo = pbs.pbs_statserver(self.con, self.attribs, 'NULL')
     148                self._disconnect()
     149               
     150                self.serverinfo = {}
     151                self._list_2_dict(serverinfo, server)
     152
     153        def get_serverinfo(self, attrib_list=None):
     154                self._statserver(attrib_list)
     155                return self.d
     156
     157        def _statqueue(self, queue_name='', attrib_list=None):
     158                """Get the queue config from the pbs server"""
     159                if attrib_list:
     160                        self._list_2_attrib(attrib_list)
     161                else:
     162                        self.attribs = 'NULL'
     163                       
     164                self._connect()
     165                queues = pbs.pbs_statque(self.con, queue_name, self.attribs, 'NULL')
     166                self._disconnect()
     167               
     168                self._list_2_dict(queues, queue)
     169
     170        def getqueue(self, name, attrib_list=None):
     171                self._statqueue(name, attrib_list)
     172                print 'getqueue ', self.d['q_express'].has_key('resources_max.walltime')
     173                q_attrs = self.d['q_express']
     174                print 'getqueue has_key', q_attrs.has_key('resources_max.walltime')
     175                return self.d
    158176       
    159     def getqueues(self, attrib_list=None):
    160         self._statqueue('', attrib_list)
    161         return self.d
    162 
    163     def _statnode(self, node_name='', attrib_list=None):
    164         """Get the node config from the pbs server"""
    165         if attrib_list:
    166            self._list_2_attrib(attrib_list)
    167         else:
    168            self.attribs = 'NULL'
    169 
    170         self._connect()
    171         nodes = pbs.pbs_statnode(self.con, node_name, self.attribs, 'NULL')
    172         self._disconnect()
    173 
    174         self.nodes = {}
    175         self._list_2_dict(nodes, node)
    176 
    177     def getnode(self, name, attrib_list=None):
    178         self._statnode(name, attrib_list)
    179         return self.d
     177        def getqueues(self, attrib_list=None):
     178                self._statqueue('', attrib_list)
     179                return self.d
     180
     181        def _statnode(self, node_name='', attrib_list=None):
     182                """Get the node config from the pbs server"""
     183                if attrib_list:
     184                        self._list_2_attrib(attrib_list)
     185                else:
     186                        self.attribs = 'NULL'
     187                       
     188                self._connect()
     189                nodes = pbs.pbs_statnode(self.con, node_name, self.attribs, 'NULL')
     190                self._disconnect()
     191               
     192                self.nodes = {}
     193                self._list_2_dict(nodes, node)
     194
     195        def getnode(self, name, attrib_list=None):
     196                self._statnode(name, attrib_list)
     197                return self.d
    180198       
    181     def getnodes(self, attrib_list=None):
    182         self._statnode('', attrib_list)
    183         return self.d
    184 
    185     def _statjob(self, job_name='', attrib_list=None):
    186         """Get the job config from the pbs server"""
    187         if attrib_list:
    188            self._list_2_attrib(attrib_list)
    189         else:
    190            self.attribs = 'NULL'
    191            
    192         self._connect()
    193         jobs = pbs.pbs_statjob(self.con, job_name, self.attribs, 'NULL')
    194         self._disconnect()
    195 
    196         self.jobs = {}
    197         self._list_2_dict(jobs, job)
    198 
    199     def getjob(self, name, attrib_list=None):
    200         self._statjob(name, attrib_list)
    201         return self.d
     199        def getnodes(self, attrib_list=None):
     200                self._statnode('', attrib_list)
     201                return self.d
     202
     203        def _statjob(self, job_name='', attrib_list=None):
     204                """Get the job config from the pbs server"""
     205                if attrib_list:
     206                        self._list_2_attrib(attrib_list)
     207                else:
     208                        self.attribs = 'NULL'
     209                       
     210                self._connect()
     211                jobs = pbs.pbs_statjob(self.con, job_name, self.attribs, 'NULL')
     212                self._disconnect()
     213               
     214                self.jobs = {}
     215                self._list_2_dict(jobs, job)
     216
     217        def getjob(self, name, attrib_list=None):
     218                self._statjob(name, attrib_list)
     219                return self.d
    202220       
    203     def getjobs(self, attrib_list=None):
    204         self._statjob('', attrib_list)
    205         return self.d
    206 
    207 class _PBSobject:
    208     TRUE  = 1
    209     FALSE = 0
    210 
    211     def __init__(self):
    212         self.attribs = {}
    213         self.name = None
    214 
    215     def __len__(self):
    216         return(len(self.attribs.keys()))
    217 
    218     def __str__(self):
    219         data = self.name + '\n'
    220         for name,value in self.attribs.items():
    221                 data = data + '\t%s = %s\n' %(name, value)
    222         return(data)
    223 
    224     __repr__ = __str__
    225 
    226     def __getitem__(self,key):
    227         if key == 'name':
    228             return self.name
    229        
    230         return(self.attribs[key])
    231 
    232     def get_value(self, key):
    233         if self.attribs.has_key(key):
    234            return self.attribs[key]
    235         else:
    236            return None
    237 
    238     def has_key(self, key):
    239         if self.attribs.has_key(key):
    240            return self.TRUE
    241         else:
    242            return self.FAlSE
    243 
    244     def keys(self):
    245         return self.attribs.keys()
    246 
    247     def values(self):
    248         return self.attribs.values()
    249 
    250     def items(self):
    251         return self.attribs.items()
    252    
     221        def getjobs(self, attrib_list=None):
     222                self._statjob('', attrib_list)
     223                return self.d
     224
     225class _PBSobject(UserDict.UserDict):
     226        TRUE  = 1
     227        FALSE = 0
     228
     229        def __init__(self):
     230                UserDict.UserDict.__init__(self)
     231                self.name = None
     232
     233        def get_value(self, key):
     234                if self.has_key(key):
     235                        return self[key]
     236                else:
     237                        return None
     238
    253239class job(_PBSobject):
    254     """PBS job class"""
    255 
    256     def is_running(self):
    257         if self.get_value('job_state') == 'Q':
    258            return self.FALSE
    259         else:
    260            return self.TRUE
     240        """PBS job class"""
     241        def is_running(self):
     242                if self.get_value('job_state') == 'Q':
     243                        return self.FALSE
     244                else:
     245                        return self.TRUE
    261246
    262247class node(_PBSobject):
    263     """PBS node class"""
    264 
    265     def is_free(self):
    266         """Check if node is free"""
    267         if self.get_value('state') == 'free':
    268               return self.TRUE
    269         else:
    270               return self.FALSE
    271 
    272     def has_job(self):
    273         """Does the node run a job"""
    274         if self.get_value('jobs'):
    275               return self.TRUE
    276         else:
    277               return self.FALSE
     248        """PBS node class"""
     249       
     250        def is_free(self):
     251                """Check if node is free"""
     252                if self.get_value('state') == 'free':
     253                        return self.TRUE
     254                else:
     255                        return self.FALSE
     256
     257        def has_job(self):
     258                """Does the node run a job"""
     259                if self.get_value('jobs'):
     260                        return self.TRUE
     261                else:
     262                        return self.FALSE
    278263
    279264class queue(_PBSobject):
    280     """PBS queue class"""
    281 
    282     def is_enabled(self):
    283         if self.get_value('enabled') == 'True':
    284            return self.TRUE
    285         else:
    286            return self.FALSE
    287 
    288     def is_execution(self):
    289         if self.get_value('queue_type') == 'Execution':
    290            return self.TRUE
    291         else:
    292            return self.FALSE
    293 
     265        """PBS queue class"""
     266        def __init__(self):
     267                UserDict.UserDict.__init__(self)
     268                self.name = None
     269
     270        def is_enabled(self):
     271                if self.get_value('enabled') == 'True':
     272                        return self.TRUE
     273                else:
     274                        return self.FALSE
     275
     276        def is_execution(self):
     277                if self.get_value('queue_type') == 'Execution':
     278                        return self.TRUE
     279                else:
     280                        return self.FALSE
    294281
    295282class server(_PBSobject):
    296     """PBS server class"""
     283        """PBS server class"""
    297284
    298285def main():
    299     p = PBSQuery()
    300 
    301     serverinfo = p.get_serverinfo()
    302     for name, server in serverinfo.items():
    303         print server
     286        p = PBSQuery()
     287        serverinfo = p.get_serverinfo()
     288        for name, server in serverinfo.items():
     289                print server
    304290        for key in server.keys():
    305291                print key, ' = ', server[key]
    306292
    307     queues = p.getqueues()
    308     for queue in queues.values():
    309         if queue.is_execution():
    310            print queue
    311 
    312     jobs = p.getjobs()
    313     for name,job in jobs.items():
    314         if job.is_running():
    315            print job
    316 
    317     l = ['state']
    318     nodes = p.getnodes(l)
    319     for name,node in nodes.items():
    320         if node.is_free():
    321            print node
     293        queues = p.getqueues()
     294        for queue in queues.values():
     295                if queue.is_execution():
     296                        print queue
     297
     298        jobs = p.getjobs()
     299        for name,job in jobs.items():
     300                if job.is_running():
     301                        print job
     302
     303        l = ['state']
     304        nodes = p.getnodes(l)
     305        for name,node in nodes.items():
     306                if node.is_free():
     307                        print node
    322308
    323309if __name__ == "__main__":
    324     main()
     310        main()
Note: See TracChangeset for help on using the changeset viewer.