Changeset 7660:62b7be191970


Ignore:
Timestamp:
11/11/07 22:41:33 (6 years ago)
Author:
Yi Qiang <yqiang@…>
Branch:
default
Children:
7661:5ecfb83c6b5b, 8377:d9717dc46a8a
Message:

Refactored stats code.

Location:
sage/dsage
Files:
1 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • sage/dsage/database/monitordb.py

    r7308 r7660  
    130130         
    131131    def update_monitor(self, host_info): 
    132         import pdb; pdb.set_trace() 
    133132        query = """UPDATE monitors 
    134133        SET hostname = ?, ip = ?, workers = ?, sage_version = ?, os = ?, 
    … …  
    251250        self.con.commit() 
    252251         
    253     def get_worker_count(self, connected, busy): 
     252    def get_worker_count(self, connected, busy=False): 
    254253        """ 
    255254        Returns the number of workers. 
    … …  
    276275        return sum(w[0] for w in result) 
    277276 
    278     def get_cpu_speed(self, connected=True, busy=True): 
     277    def get_cpu_speed(self, connected=True, busy=False): 
    279278        """ 
    280279        Returns the aggregate cpu speed in Mhz. 
    … …  
    285284        """ 
    286285         
    287         if connected: 
     286        if connected and busy: 
    288287            query = """SELECT cpu_speed, workers FROM monitors  
    289288            WHERE connected AND busy""" 
     289        elif connected: 
     290            query = """SELECT cpu_speed, workers FROM monitors  
     291            WHERE connected""" 
    290292        else: 
    291293            query = """SELECT cpu_speed, workers FROM monitors""" 

  • sage/dsage/scripts/dsage_server.py

    r7655 r7660  
    117117    return options 
    118118 
    119 # def write_stats(dsage_server, stats_file): 
    120 #     check_dsage_dir() 
    121 #     try: 
    122 #         fname = os.path.join(DSAGE_DIR, stats_file) 
    123 #         f = open(fname, 'w') 
    124 #         f.write(dsage_server.generate_xml_stats()) 
    125 #         f.close() 
    126 #     except Exception, msg: 
    127 #         print Exception 
    128 #         print 'Error writing stats: %s' % (msg) 
    129 #         return 
    130  
    131119def create_manhole(): 
    132120    """ 

  • sage/dsage/scripts/dsage_worker.py

    r7650 r7660  
    128128        except Exception, msg: 
    129129            log.msg(msg) 
    130             import pdb; pdb.set_trace() 
    131130            self.report_failure(msg) 
    132131            self.restart() 
    … …  
    734733            return 
    735734     
    736         factory = pb.PBClientFactory()         
    737735        self.factory = PBClientFactory() 
    738736        try: 

  • sage/dsage/server/server.py

    r7655 r7660  
    357357         
    358358        return count 
    359      
    360     def generate_xml_stats(self): 
    361         """ 
    362         This method returns a an XML document to be consumed by the  
    363         Mac OS X Dashboard widget and the web server. 
    364          
    365         """ 
    366          
    367         def create_gauge(doc): 
    368             gauge = doc.createElement('gauge') 
    369             doc.appendChild(gauge) 
    370  
    371             return doc, gauge 
    372  
    373         def add_totalAgentCount(doc, gauge): 
    374             totalAgentCount = doc.createElement('totalAgentCount') 
    375             gauge.appendChild(totalAgentCount) 
    376             working_workers = self.monitordb.get_worker_count(connected=True, 
    377                                                               busy=True) 
    378             free_workers = self.monitordb.get_worker_count(connected=True, 
    379                                                            busy=False) 
    380             disconnected_workers = self.monitordb.get_worker_count( 
    381                                    connected=False, 
    382                                    busy=False) 
    383             total_workers = (working_workers +  
    384                              free_workers +  
    385                              disconnected_workers) 
    386             count = doc.createTextNode(str(total_workers)) 
    387             totalAgentCount.appendChild(count) 
    388  
    389             return doc, totalAgentCount 
    390          
    391         def add_onlineAgentCount(doc, gauge): 
    392             onlineAgentCount = doc.createElement('onlineAgentCount') 
    393             gauge.appendChild(onlineAgentCount) 
    394             free_workers = self.monitordb.get_worker_count(connected=True, 
    395                                                            busy=False) 
    396             busy_workers = self.monitordb.get_worker_count(connected=True, 
    397                                                            busy=True) 
    398             count = doc.createTextNode(str(free_workers + busy_workers)) 
    399             onlineAgentCount.appendChild(count) 
    400              
    401             return doc, onlineAgentCount 
    402              
    403         def add_offlineAgentCount(doc, gauge): 
    404             offlineAgentCount = doc.createElement('offlineAgentCount') 
    405             gauge.appendChild(offlineAgentCount) 
    406             worker_count = self.monitordb.get_worker_count(connected=False, 
    407                                                            busy=False) 
    408             count = doc.createTextNode(str(worker_count)) 
    409             offlineAgentCount.appendChild(count) 
    410              
    411             return doc, offlineAgentCount 
    412              
    413         def add_workingAgentCount(doc, gauge): 
    414             workingAgentCount = doc.createElement('workingAgentCount') 
    415             gauge.appendChild(workingAgentCount) 
    416             worker_count = self.monitordb.get_worker_count(connected=True, 
    417                                                            busy=True) 
    418             count = doc.createTextNode(str(worker_count)) 
    419             workingAgentCount.appendChild(count) 
    420              
    421             return doc, workingAgentCount 
    422          
    423         def add_availableAgentCount(doc, gauge): 
    424             availableAgentCount = doc.createElement('availableAgentCount') 
    425             gauge.appendChild(availableAgentCount) 
    426             worker_count = self.monitordb.get_worker_count(connected=True, 
    427                                                            busy=False) 
    428             count = doc.createTextNode(str(worker_count)) 
    429             availableAgentCount.appendChild(count) 
    430              
    431             return doc, availableAgentCount 
    432          
    433         def add_unavailableAgentCount(doc, gauge): 
    434             unavailableAgentCount = doc.createElement('unavailableAgentCount') 
    435             gauge.appendChild(unavailableAgentCount) 
    436             worker_count = self.monitordb.get_worker_count(connected=True, 
    437                                                            busy=True) 
    438             count = doc.createTextNode(str(worker_count)) 
    439             unavailableAgentCount.appendChild(count) 
    440              
    441             return doc, unavailableAgentCount 
    442              
    443         def add_workingMegaHertz(doc, gauge): 
    444             workingMegaHertz = doc.createElement('workingMegaHertz') 
    445             gauge.appendChild(workingMegaHertz) 
    446             cpu_speed = self.monitordb.get_cpu_speed(connected=True, 
    447                                                      busy=True) 
    448             mhz = doc.createTextNode(str(cpu_speed)) 
    449             workingMegaHertz.appendChild(mhz) 
    450  
    451             return doc, workingMegaHertz 
    452  
    453         def add_availableProcessorCount(doc, gauge): 
    454             pass 
    455              
    456         def add_unavailableProcessorCount(doc, gauge): 
    457             pass 
    458              
    459         def add_onlineProcessorCount(doc, gauge): 
    460             onlineProcessorCount = doc.createElement('onlineProcessorCount') 
    461             gauge.appendChild(onlineProcessorCount) 
    462             cpu_count = self.monitordb.get_cpu_count(connected=True) 
    463             c = doc.createTextNode(str(cpu_count)) 
    464             onlineProcessorCount.appendChild(c) 
    465              
    466             return doc, onlineProcessorCount 
    467          
    468         def add_offlineProcessorCount(doc, gauge): 
    469             offlineProcessorCount = doc.createElement('offlineProcessorCount') 
    470             gauge.appendChild(offlineProcessorCount) 
    471             cpu_count = self.monitordb.get_cpu_count(connected=False) 
    472             c = doc.createTextNode(str(cpu_count)) 
    473             offlineProcessorCount.appendChild(c) 
    474              
    475             return doc, offlineProcessorCount 
    476              
    477         def add_workingProcessorCount(doc, gauge): 
    478             workingProcessorCount = doc.createElement('workingProcessorCount') 
    479             gauge.appendChild(workingProcessorCount) 
    480             worker_count = self.monitordb.get_cpu_count(connected=True) 
    481             pcount = doc.createTextNode(str(worker_count)) 
    482             workingProcessorCount.appendChild(pcount) 
    483  
    484             return doc, workingProcessorCount 
    485          
    486         def add_workingAgentPercentage(doc, gauge): 
    487             workingAgentPercentage = doc.createElement( 
    488                                                     'workingAgentPercentage') 
    489             gauge.appendChild(workingAgentPercentage) 
    490             working_workers = self.monitordb.get_worker_count(connected=True, 
    491                                                               busy=True) 
    492             free_workers = self.monitordb.get_worker_count(connected=True, 
    493                                                            busy=False) 
    494             disconnected_workers = self.monitordb.get_worker_count( 
    495                                    connected=False, 
    496                                    busy=False) 
    497             total_workers = (working_workers +  
    498                              free_workers +  
    499                              disconnected_workers) 
    500              
    501             if total_workers != 0: 
    502                 worker_percentage = (float(working_workers / total_workers) * 
    503                 100) 
    504             else: 
    505                 worker_percentage = 0.0 
    506             percentage = doc.createTextNode(str(worker_percentage)) 
    507             workingAgentPercentage.appendChild(percentage) 
    508              
    509             return doc, workingAgentPercentage 
    510              
    511         def add_date(doc, gauge): 
    512             date = datetime.datetime.now() 
    513  
    514             year = doc.createElement('Year') 
    515             gauge.appendChild(year) 
    516             year.appendChild(doc.createTextNode(str(date.year))) 
    517  
    518             seconds = doc.createElement('Seconds') 
    519             gauge.appendChild(seconds) 
    520             seconds.appendChild(doc.createTextNode(str(date.second))) 
    521  
    522             minutes = doc.createElement('Minutes') 
    523             gauge.appendChild(minutes) 
    524             minutes.appendChild(doc.createTextNode(str(date.minute))) 
    525  
    526             return doc, year, seconds, minutes 
    527          
    528         doc = xml.dom.minidom.Document() 
    529         doc, gauge = create_gauge(doc) 
    530          
    531         add_onlineAgentCount(doc, gauge) 
    532         add_offlineAgentCount(doc, gauge) 
    533         add_availableAgentCount(doc, gauge) 
    534         add_unavailableAgentCount(doc, gauge) 
    535         add_totalAgentCount(doc, gauge) 
    536         add_workingAgentCount(doc, gauge) 
    537         add_workingAgentPercentage(doc, gauge) 
    538         add_onlineProcessorCount(doc, gauge) 
    539         add_availableProcessorCount(doc, gauge) 
    540         add_unavailableProcessorCount(doc, gauge) 
    541         add_workingProcessorCount(doc, gauge) 
    542         add_workingMegaHertz(doc, gauge) 
    543          
    544         add_date(doc, gauge) 
    545         s = cStringIO.StringIO()     
    546         doc.writexml(s, newl='\n') 
    547          
    548         return s.getvalue() 
    549359 
    550360class DSageWorkerServer(DSageServer): 

  • sage/dsage/server/stats.py

    r7658 r7660  
    2222                                   dump, 
    2323                                   XML) 
     24from cStringIO import StringIO 
    2425                                    
    25 class XMLStats(self, dsage_server): 
     26class XMLStats(object): 
    2627    """ 
    2728    Generates a XML document containing statistics for the server. 
    … …  
    3637    def gen_xml(self): 
    3738        self.add_workers() 
    38         self.add_working_mhz() 
     39        self.add_mhz() 
    3940         
    40         return dump(self.root) 
     41        xml_stream = StringIO() 
     42        ET(self.root).write(xml_stream) 
     43         
     44        return xml_stream.getvalue() 
     45     
     46    def add_element(self, element, value): 
     47        SubElement(self.root, element).text = str(value) 
    4148         
    4249    def add_workers(self): 
    … …  
    5057        free_workers = self.monitordb.get_worker_count(connected=True, 
    5158                                                       busy=False) 
    52         offline_workers = self.monitordb.get_worker_count(connected=False) 
    53         total_workers = (working_workers +  
    54                          free_workers +  
    55                          disconnected_workers) 
    5659                          
    57         bw = SubElement(self.root, 'busy_workers') 
    58         bw.text = busy_workers 
    59         fw = SubElement(self.root, 'free_workers') 
    60         fw.text = free_workers 
    61         ow = SubElement(self.root, 'offline_workers') 
    62         ow.text = offline_workers 
    63         tw = SubElement(self.root, 'total_workers') 
    64         tw.text = total_workers 
     60        self.add_element('busy_workers', busy_workers) 
     61        self.add_element('free_workers', free_workers) 
    6562     
    66     def add_working_mhz(self): 
     63    def add_mhz(self): 
    6764        """ 
    6865        Adds the current working MHz to root.""" 
    … …  
    7067        working_mhz = self.monitordb.get_cpu_speed(connected=True, 
    7168                                                   busy=True) 
    72         wm = SubElement(self.root, 'working_mhz') 
    73         wm.text = working_mhz 
    74          
    75 # def generate_xml_stats(self): 
    76 #     """ 
    77 #     This method returns a an XML document to be consumed by the  
    78 #     Mac OS X Dashboard widget and the web server. 
    79 #      
    80 #     """ 
    81 #          
    82 #     def add_onlineProcessorCount(doc, gauge): 
    83 #         onlineProcessorCount = doc.createElement('onlineProcessorCount') 
    84 #         gauge.appendChild(onlineProcessorCount) 
    85 #         cpu_count = self.monitordb.get_cpu_count(connected=True) 
    86 #         c = doc.createTextNode(str(cpu_count)) 
    87 #         onlineProcessorCount.appendChild(c) 
    88 #          
    89 #         return doc, onlineProcessorCount 
    90 #      
    91 #     def add_offlineProcessorCount(doc, gauge): 
    92 #         offlineProcessorCount = doc.createElement('offlineProcessorCount') 
    93 #         gauge.appendChild(offlineProcessorCount) 
    94 #         cpu_count = self.monitordb.get_cpu_count(connected=False) 
    95 #         c = doc.createTextNode(str(cpu_count)) 
    96 #         offlineProcessorCount.appendChild(c) 
    97 #          
    98 #         return doc, offlineProcessorCount 
    99 #          
    100 #     def add_workingProcessorCount(doc, gauge): 
    101 #         workingProcessorCount = doc.createElement('workingProcessorCount') 
    102 #         gauge.appendChild(workingProcessorCount) 
    103 #         worker_count = self.monitordb.get_cpu_count(connected=True) 
    104 #         pcount = doc.createTextNode(str(worker_count)) 
    105 #         workingProcessorCount.appendChild(pcount) 
    106 #  
    107 #         return doc, workingProcessorCount 
    108 #      
    109 #     def add_workingAgentPercentage(doc, gauge): 
    110 #         workingAgentPercentage = doc.createElement( 
    111 #                                                 'workingAgentPercentage') 
    112 #         gauge.appendChild(workingAgentPercentage) 
    113 #         working_workers = self.monitordb.get_worker_count(connected=True, 
    114 #                                                           busy=True) 
    115 #         free_workers = self.monitordb.get_worker_count(connected=True, 
    116 #                                                        busy=False) 
    117 #         disconnected_workers = self.monitordb.get_worker_count( 
    118 #                                connected=False, 
    119 #                                busy=False) 
    120 #         total_workers = (working_workers +  
    121 #                          free_workers +  
    122 #                          disconnected_workers) 
    123 #          
    124 #         if total_workers != 0: 
    125 #             worker_percentage = (float(working_workers / total_workers) * 
    126 #             100) 
    127 #         else: 
    128 #             worker_percentage = 0.0 
    129 #         percentage = doc.createTextNode(str(worker_percentage)) 
    130 #         workingAgentPercentage.appendChild(percentage) 
    131 #          
    132 #         return doc, workingAgentPercentage 
    133 #          
    134 #     def add_date(doc, gauge): 
    135 #         date = datetime.datetime.now() 
    136 #  
    137 #         year = doc.createElement('Year') 
    138 #         gauge.appendChild(year) 
    139 #         year.appendChild(doc.createTextNode(str(date.year))) 
    140 #  
    141 #         seconds = doc.createElement('Seconds') 
    142 #         gauge.appendChild(seconds) 
    143 #         seconds.appendChild(doc.createTextNode(str(date.second))) 
    144 #  
    145 #         minutes = doc.createElement('Minutes') 
    146 #         gauge.appendChild(minutes) 
    147 #         minutes.appendChild(doc.createTextNode(str(date.minute))) 
    148 #  
    149 #         return doc, year, seconds, minutes 
    150 #      
    151 #     doc = xml.dom.minidom.Document() 
    152 #     doc, gauge = create_gauge(doc) 
    153 #      
    154 #     add_onlineAgentCount(doc, gauge) 
    155 #     add_offlineAgentCount(doc, gauge) 
    156 #     add_availableAgentCount(doc, gauge) 
    157 #     add_unavailableAgentCount(doc, gauge) 
    158 #     add_totalAgentCount(doc, gauge) 
    159 #     add_workingAgentCount(doc, gauge) 
    160 #     add_workingAgentPercentage(doc, gauge) 
    161 #     add_onlineProcessorCount(doc, gauge) 
    162 #     add_availableProcessorCount(doc, gauge) 
    163 #     add_unavailableProcessorCount(doc, gauge) 
    164 #     add_workingProcessorCount(doc, gauge) 
    165 #     add_workingMegaHertz(doc, gauge) 
    166 #      
    167 #     add_date(doc, gauge) 
    168 #     s = cStringIO.StringIO()     
    169 #     doc.writexml(s, newl='\n') 
    170 #      
    171 #     return s.getvalue() 
     69        total_mhz = self.monitordb.get_cpu_speed(connected=True, 
     70                                                 busy=False) 
     71                                                  
     72        self.add_element('working_mhz', working_mhz) 
     73        self.add_element('total_mhz', total_mhz) 

  • sage/dsage/web/web_server.py

    r7658 r7660  
    2929from sage.dsage.server.stats import XMLStats 
    3030 
     31from xml.etree.ElementTree import (ElementTree as ET, 
     32                                   Element, 
     33                                   SubElement, 
     34                                   dump, 
     35                                   XML) 
     36                                    
    3137SAGE_ROOT  = os.environ['SAGE_ROOT'] 
    3238DSAGE_LOCAL = SAGE_ROOT + '/local/dsage' 
    … …  
    219225class GetServerDetails(resource.PostableResource): 
    220226    """ 
    221     Returns an XML file containing the server resources. 
     227    Returns an HTML table containing the server resources. 
    222228     
    223229    """ 
    … …  
    225231    def __init__(self, dsage_server): 
    226232        self.dsage_server = dsage_server 
    227      
    228     def gen_html(self, stats_xml): 
     233        self.xml_stats = XMLStats(self.dsage_server) 
     234         
     235    def gen_html(self): 
    229236        """ 
    230237        generates html snippet from xml stats 
    231238         
    232239        """ 
    233          
    234         from xml.etree.ElementTree import (ElementTree as ET, 
    235                                            Element, 
    236                                            SubElement, 
    237                                            dump, 
    238                                            XML) 
    239          
    240         mapping = {'onlineAgentCount': 'Online Workers', 
    241                    'offlineAgentCount': 'Offline Workers', 
    242                    'totalAgentCount': 'Total Workers', 
    243                    'onlineProcessorCount': 'Online CPUs', 
    244                    'workingProcessorCount': 'Working CPUs', 
    245                    'workingAgentPercentage': 'Working %'} 
    246         # html = """ 
    247         # <thead> 
    248         # <tr> 
    249         #    <th>Online Workers</th> 
    250         #    <th>Offline Workers</th> 
    251         #    <th>Total Workers</th> 
    252         #    <th>Online Processors</th> 
    253         #    <th>Working Processors</th> 
    254         #    <th>Working MHz</th> 
    255         #    <th>Percent Working</th> 
    256         # </tr> 
    257         # </thead> 
    258         # <tbody> 
    259         # """ 
    260         #  
     240 
     241        self.xml_stats.gen_xml() 
     242         
    261243        html = """ 
    262244        <thead> 
    … …  
    265247        <th>Value</th> 
    266248        <tbody>""" 
    267         # build StringIO object 
    268         tree = ET() 
    269         tree.parse(StringIO(stats_xml)) 
    270         root = tree.getroot() 
    271         for i, elem in enumerate(root.getchildren()):       
    272             if elem.tag in ('onlineAgentCount',  
    273                             'offlineAgentCount',  
    274                             'totalAgentCount', 
    275                             'onlineProcessorCount', 
    276                             'workingProcessorCount', 
    277                             'workingAgentPercentage'): 
     249 
     250        for i, elem in enumerate(self.xml_stats.root.getchildren()):       
    278251                html += """ 
    279252                <tr> 
    … …  
    281254                    <td>%s</td> 
    282255                </tr> 
    283                 """ % (mapping[elem.tag], elem.text) 
     256                """ % (' '.join(w.title() for w in elem.tag.split("_")),  
     257                       elem.text) 
    284258 
    285259        html += """ 
    … …  
    294268         
    295269        """ 
    296          
    297          
    298         stats_xml = XMLStats(self.dsage_server).gen_xml() 
    299          
    300         # html = self.gen_html(stats_xml) 
    301          
    302         return http.Response(stream=stats_xml) 
     270                         
     271        return http.Response(stream=self.gen_html()) 
Note: See TracChangeset for help on using the changeset viewer.