tko/display.py

   1 import os, re, string, sys
   2 import frontend, reason_qualifier
   3
   4 color_map = {
   5         'header'        : '#e5e5c0', # greyish yellow
   6         'blank'         : '#ffffff', # white
   7         'plain_text'    : '#e5e5c0', # greyish yellow
   8         'borders'       : '#bbbbbb', # grey
   9         'white'         : '#ffffff', # white
  10         'green'         : '#66ff66', # green
  11         'yellow'        : '#fffc00', # yellow
  12         'red'           : '#ff6666', # red
  13
  14         #### additional keys for shaded color of a box
  15         #### depending on stats of GOOD/FAIL
  16         '100pct'  : '#32CD32', # green, 94% to 100% of success
  17         '95pct'   : '#c0ff80', # step twrds yellow, 88% to 94% of success
  18         '90pct'   : '#ffff00', # yellow, 82% to 88%
  19         '85pct'   : '#ffc040', # 76% to 82%
  20         '75pct'   : '#ff4040', # red, 1% to 76%
  21         '0pct'    : '#d080d0', # violet, <1% of success
  22
  23 }
  24
  25 _brief_mode = False
  26
  27
  28 def set_brief_mode():
  29     global _brief_mode
  30     _brief_mode = True
  31
  32
  33 def is_brief_mode():
  34     return _brief_mode
  35
  36
  37 def color_keys_row():
  38     """ Returns one row table with samples of 'NNpct' colors
  39             defined in the color_map
  40             and numbers of corresponding %%
  41     """
  42     ### This function does not require maintenance in case of
  43     ### color_map augmenting - as long as
  44     ### color keys for box shading have names that end with 'pct'
  45     keys = filter(lambda key: key.endswith('pct'), color_map.keys())
  46     def num_pct(key):
  47         return int(key.replace('pct',''))
  48     keys.sort(key=num_pct)
  49     html = ''
  50     for key in keys:
  51         html+= "\t\t\t<td bgcolor =%s>&nbsp;&nbsp;&nbsp;</td>\n"\
  52                         % color_map[key]
  53         hint = key.replace('pct',' %')
  54         if hint[0]<>'0': ## anything but 0 %
  55             hint = 'to ' + hint
  56         html+= "\t\t\t<td> %s </td>\n" % hint
  57
  58     html = """
  59 <table width = "500" border="0" cellpadding="2" cellspacing="2">\n
  60     <tbody>\n
  61             <tr>\n
  62 %s
  63             </tr>\n
  64     </tbody>
  65 </table><br>
  66 """ % html
  67     return html
  68
  69
  70 def calculate_html(link, data, tooltip=None, row_label=None, column_label=None):
  71     if not is_brief_mode():
  72         hover_text = '%s:%s' % (row_label, column_label)
  73         if data:  ## cell is not empty
  74             hover_text += '<br>%s' % tooltip
  75         else:
  76             ## avoid "None" printed in empty cells
  77             data = '&nbsp;'
  78         html = ('<center><a class="info" href="%s">'
  79                 '%s<span>%s</span></a></center>' %
  80                 (link, data, hover_text))
  81         return html
  82     # no hover if embedded into AFE but links shall redirect to new window
  83     if data: ## cell is non empty
  84         html =  '<a href="%s" target="_blank">%s</a>' % (link, data)
  85         return html
  86     else: ## cell is empty
  87         return '&nbsp;'
  88
  89
  90 class box:
  91     def __init__(self, data, color_key = None, header = False, link = None,
  92                  tooltip = None, row_label = None, column_label = None):
  93
  94         ## in brief mode we display grid table only and nothing more
  95         ## - mouse hovering feature is stubbed in brief mode
  96         ## - any link opens new window or tab
  97
  98         redirect = ""
  99         if is_brief_mode():
 100             ## we are acting under AFE
 101             ## any link shall open new window
 102             redirect = " target=NEW"
 103
 104         if data:
 105             data = "<tt>%s</tt>" % data
 106
 107         if link and not tooltip:
 108             ## FlipAxis corner, column and row headers
 109             self.data = ('<a href="%s"%s>%s</a>' %
 110                          (link, redirect, data))
 111         else:
 112             self.data = calculate_html(link, data, tooltip,
 113                                        row_label, column_label)
 114
 115         if color_map.has_key(color_key):
 116             self.color = color_map[color_key]
 117         elif header:
 118             self.color = color_map['header']
 119         elif data:
 120             self.color = color_map['plain_text']
 121         else:
 122             self.color = color_map['blank']
 123         self.header = header
 124
 125
 126     def html(self):
 127         if self.data:
 128             data = self.data
 129         else:
 130             data = '&nbsp'
 131
 132         if self.header:
 133             box_html = 'th'
 134         else:
 135             box_html = 'td'
 136
 137         return "<%s bgcolor=%s>%s</%s>" % \
 138                                 (box_html, self.color, data, box_html)
 139
 140
 141 def grade_from_status(status_idx, status):
 142     # % of goodness
 143     # GOOD (6)  -> 1
 144     # TEST_NA (8) is not counted
 145     # ##  If the test doesn't PASS, it FAILS
 146     # else -> 0
 147
 148     if status == status_idx['GOOD']:
 149         return 1.0
 150     else:
 151         return 0.0
 152
 153
 154 def average_grade_from_status_count(status_idx, status_count):
 155     average_grade = 0
 156     total_count = 0
 157     for key in status_count.keys():
 158         if key not in (status_idx['TEST_NA'], status_idx['RUNNING']):
 159             average_grade += (grade_from_status(status_idx, key)
 160                                     * status_count[key])
 161             total_count += status_count[key]
 162     if total_count != 0:
 163         average_grade = average_grade / total_count
 164     else:
 165         average_grade = 0.0
 166     return average_grade
 167
 168
 169 def shade_from_status_count(status_idx, status_count):
 170     if not status_count:
 171         return None
 172
 173     ## average_grade defines a shade of the box
 174     ## 0 -> violet
 175     ## 0.76 -> red
 176     ## 0.88-> yellow
 177     ## 1.0 -> green
 178     average_grade = average_grade_from_status_count(status_idx, status_count)
 179
 180     ## find appropiate keyword from color_map
 181     if average_grade<0.01:
 182         shade = '0pct'
 183     elif average_grade<0.75:
 184         shade = '75pct'
 185     elif average_grade<0.85:
 186         shade = '85pct'
 187     elif average_grade<0.90:
 188         shade = '90pct'
 189     elif average_grade<0.95:
 190         shade = '95pct'
 191     else:
 192         shade = '100pct'
 193
 194     return shade
 195
 196
 197 def status_html(db, box_data, shade):
 198     """
 199     status_count: dict mapping from status (integer key) to count
 200     eg. { 'GOOD' : 4, 'FAIL' : 1 }
 201     """
 202     status_count_subset = box_data.status_count.copy()
 203     test_na = db.status_idx['TEST_NA']
 204     running = db.status_idx['RUNNING']
 205     good = db.status_idx['GOOD']
 206
 207     status_count_subset[test_na] = 0  # Don't count TEST_NA
 208     status_count_subset[running] = 0  # Don't count RUNNING
 209     html = "%d&nbsp;/&nbsp;%d " % (status_count_subset.get(good, 0),
 210                                    sum(status_count_subset.values()))
 211     if test_na in box_data.status_count.keys():
 212         html += ' (%d&nbsp;N/A)' % box_data.status_count[test_na]
 213     if running in box_data.status_count.keys():
 214         html += ' (%d&nbsp;running)' % box_data.status_count[running]
 215
 216     if box_data.reasons_list:
 217         reasons_list = box_data.reasons_list
 218         aggregated_reasons_list = \
 219                 reason_qualifier.aggregate_reason_fields(reasons_list)
 220         for reason in aggregated_reasons_list:
 221             ## a bit of more postprocessing
 222             ## to look nicer in a cell
 223             ## in future: to do subtable within the cell
 224             reason = reason.replace('<br>','\n')
 225             reason = reason.replace('<','[').replace('>',']')
 226             reason = reason.replace('|','\n').replace('&',' AND ')
 227             reason = reason.replace('\n','<br>')
 228             html += '<br>' + reason
 229
 230     tooltip = ""
 231     for status in sorted(box_data.status_count.keys(), reverse = True):
 232         status_word = db.status_word[status]
 233         tooltip += "%d %s " % (box_data.status_count[status], status_word)
 234     return (html,tooltip)
 235
 236
 237 def status_count_box(db, tests, link = None):
 238     """
 239     Display a ratio of total number of GOOD tests
 240     to total number of all tests in the group of tests.
 241     More info (e.g. 10 GOOD, 2 WARN, 3 FAIL) is in tooltips
 242     """
 243     if not tests:
 244         return box(None, None)
 245
 246     status_count = {}
 247     for test in tests:
 248         count = status_count.get(test.status_num, 0)
 249         status_count[test.status_num] = count + 1
 250     return status_precounted_box(db, status_count, link)
 251
 252
 253 def status_precounted_box(db, box_data, link = None,
 254                                  x_label = None, y_label = None):
 255     """
 256     Display a ratio of total number of GOOD tests
 257     to total number of all tests in the group of tests.
 258     More info (e.g. 10 GOOD, 2 WARN, 3 FAIL) is in tooltips
 259     """
 260     status_count = box_data.status_count
 261     if not status_count:
 262         return box(None, None)
 263
 264     shade = shade_from_status_count(db.status_idx, status_count)
 265     html,tooltip = status_html(db, box_data, shade)
 266     precounted_box = box(html, shade, False, link, tooltip,
 267                             x_label, y_label)
 268     return precounted_box
 269
 270
 271 def print_table(matrix):
 272     """
 273     matrix: list of lists of boxes, giving a matrix of data
 274     Each of the inner lists is a row, not a column.
 275
 276     Display the given matrix of data as a table.
 277     """
 278
 279     print ('<table bgcolor="%s" cellspacing="1" cellpadding="5" '
 280            'style="margin-right: 200px;">') % (
 281            color_map['borders'])
 282     for row in matrix:
 283         print '<tr>'
 284         for element in row:
 285             print element.html()
 286         print '</tr>'
 287     print '</table>'
 288
 289
 290 def sort_tests(tests):
 291     kernel_order = ['patch', 'config', 'build', 'mkinitrd', 'install']
 292
 293     results = []
 294     for kernel_op in kernel_order:
 295         test = 'kernel.' + kernel_op
 296         if tests.count(test):
 297             results.append(test)
 298             tests.remove(test)
 299     if tests.count('boot'):
 300         results.append('boot')
 301         tests.remove('boot')
 302     return results + sorted(tests)
 303
 304
 305 def print_main_header():
 306     hover_css="""\
 307 a.info{
 308 position:relative; /*this is the key*/
 309 z-index:1
 310 color:#000;
 311 text-decoration:none}
 312
 313 a.info:hover{z-index:25;}
 314
 315 a.info span{display: none}
 316
 317 a.info:hover span{ /*the span will display just on :hover state*/
 318 display:block;
 319 position:absolute;
 320 top:1em; left:1em;
 321 min-width: 100px;
 322 overflow: visible;
 323 border:1px solid #036;
 324 background-color:#fff; color:#000;
 325 text-align: left
 326 }
 327 """
 328     print '<head><style type="text/css">'
 329     print 'a { text-decoration: none }'
 330     print hover_css
 331     print '</style></head>'
 332     print '<h2>'
 333     print '<a href="compose_query.cgi">Functional</a>'
 334     print '&nbsp&nbsp&nbsp'
 335     print '<a href="machine_benchmark.cgi">Performance</a>'
 336     print '&nbsp&nbsp&nbsp'
 337     print '<a href="http://ossipedia.ipa.go.jp/crackerjack/compare_results.html">Crackerjack</a>'
 338     print '&nbsp&nbsp&nbsp'
 339     print '<a href="http://autotest.kernel.org">[About Page]</a>'
 340     print '</h2><p>'
 341
 342
 343 def group_name(group):
 344     name = re.sub('_', '<br>', group.name)
 345     if re.search('/', name):
 346         (owner, machine) = name.split('/', 1)
 347         name = owner + '<br>' + machine
 348     return name
 349
 350 def print_add_test_form(available_params, attributes, cleared):
 351     print '<form method="post">'
 352     print '<input type="hidden" name="attributes" value="%s" />' % attributes
 353     print '<input type="hidden" name="cleared" value="%s" />' % cleared
 354     print '<select name="key">'
 355     for text in available_params:
 356         print '<option value="%s">%s</option>' % (text, text)
 357     print '</select>'
 358     print '<input type="submit" name="add" value="Add test" />'
 359     print '<input type="submit" name="clear" value="Clear all tests" />'
 360     print '<input type="submit" name="reset" value="Reset" />'
 361     print '</form>'