web/MonitorWeb/monitorweb/controllers.py

   1 import turbogears as tg
   2 from turbogears import controllers, expose, flash, exception_handler
   3 from turbogears import widgets
   4 from cherrypy import request, response
   5 import cherrypy
   6 # from monitorweb import model
   7 # import logging
   8 # log = logging.getLogger("monitorweb.controllers")
   9 import re
  10 from monitor.database.info.model import *
  11 #from monitor.database.zabbixapi.model import *
  12 #from monitor.database.dborm import zab_session as session
  13 #from monitor.database.dborm import zab_metadata as metadata
  14 from monitor_xmlrpc import MonitorXmlrpcServer
  15
  16 from monitor import reboot
  17 from monitor import scanapi
  18 import time
  19
  20 from monitor.wrapper.plccache import plcdb_hn2lb as site_hn2lb
  21
  22 from monitorweb.templates.links import *
  23
  24 class ObjectQueryFields(widgets.WidgetsList):
  25         """The WidgetsList defines the fields of the form."""
  26         pass
  27
  28
  29
  30 class NodeQueryFields(widgets.WidgetsList):
  31         """The WidgetsList defines the fields of the form."""
  32
  33         object = widgets.RadioButtonList(label="Query Type", options=[('nodes', 'All Nodes'),
  34                                                                                                                           ('nodehistory', 'Single Node History'),
  35                                                                                                                           #('sites', 'All Sites'),
  36                                                                                                                           #('sitehistory', 'Single Site History'),
  37                                                                                                                           ], default="nodes")
  38         nodehistory_hostname = widgets.TextField(label="Hostname Node History", attrs={'size':30})
  39
  40         hostname = widgets.CheckBox(label="Hostname")
  41         firewall = widgets.CheckBox(label="Firewall?")
  42         dns_status = widgets.CheckBox(label="DNS Status")
  43         external_dns_status = widgets.CheckBox(label="Hostname Resolves?")
  44         kernel_version = widgets.CheckBox(label="Kernel")
  45         observed_status = widgets.CheckBox(label="Observed Status")
  46         port_status = widgets.CheckBox(label="Port Status")
  47         rpms = widgets.CheckBox(label="RPM")
  48         rpmvalue = widgets.TextField(label="RPM Pattern")
  49
  50 class QueryForm(widgets.TableForm):
  51     template = """
  52     <form xmlns:py="http://purl.org/kid/ns#"
  53         name="${name}"
  54         action="${action}"
  55         method="${method}"
  56         class="tableform"
  57         py:attrs="form_attrs"
  58     >
  59         <div py:for="field in hidden_fields"
  60             py:replace="field.display(value_for(field), **params_for(field))"
  61         />
  62         <table border="0" cellspacing="0" cellpadding="2" py:attrs="table_attrs">
  63             <tr py:for="i, field in enumerate(fields)"
  64                 class="${i%2 and 'odd' or 'even'}"
  65             >
  66                 <th>
  67                     <label class="fieldlabel" for="${field.field_id}" py:content="field.label" />
  68                 </th>
  69                 <td>
  70                     <span py:replace="field.display(value_for(field), **params_for(field))" />
  71                     <span py:if="error_for(field)" class="fielderror" py:content="error_for(field)" />
  72                     <span py:if="field.help_text" class="fieldhelp" py:content="field.help_text" />
  73                 </td>
  74             </tr>
  75             <tr>
  76                 <td>&#160;</td>
  77                 <td py:content="submit.display(submit_text)" />
  78             </tr>
  79         </table>
  80     </form>
  81         """
  82
  83 def getNodeQueryForm():
  84         return QueryForm(fields=NodeQueryFields(), action="query")
  85
  86 # make it easier group objects without invoking the elixir auto-write feature.
  87 class aggregate: pass
  88
  89
  90 def query_to_dict(query):
  91         """ take a url query string and chop it up """
  92         val = {}
  93         query_fields = query.split('&')
  94         for f in query_fields:
  95                 (k,v) = urllib.splitvalue(f)
  96                 val[k] = v
  97
  98         return val
  99
 100 def format_ports(data, pcumodel=None):
 101         retval = []
 102         filtered_length=0
 103
 104         if pcumodel:
 105                 supported_ports=reboot.model_to_object(pcumodel).supported_ports
 106         else:
 107                 # ports of a production node
 108                 supported_ports=[22,80,806]
 109
 110         if data and len(data.keys()) > 0 :
 111                 for port in supported_ports:
 112                         try:
 113                                 state = data[str(port)]
 114                         except:
 115                                 state = "unknown"
 116
 117                         if state == "filtered":
 118                                 filtered_length += 1
 119
 120                         retval.append( (port, state) )
 121
 122         if retval == []:
 123                 retval = [( "Closed/Filtered", "state" )]
 124
 125         if filtered_length == len(supported_ports):
 126                 retval = [( "All Filtered", "state" )]
 127
 128         return retval
 129
 130 def format_pcu_shortstatus(pcu):
 131         status = "error"
 132         if pcu:
 133                 if pcu.reboot_trial_status == str(0):
 134                         status = "Ok"
 135                 elif pcu.reboot_trial_status == "NetDown" or pcu.reboot_trial_status == "Not_Run":
 136                         status = pcu.reboot_trial_status
 137                 else:
 138                         status = "error"
 139
 140         return status
 141
 142 def prep_pcu_for_display(pcu):
 143         agg = aggregate()
 144         agg.pcu = pcu
 145
 146         try:
 147                 agg.loginbase = PlcSite.query.get(pcu.plc_pcu_stats['site_id']).plc_site_stats['login_base']
 148         except:
 149                 agg.loginbase = "unknown"
 150
 151         agg.pcuhist = HistoryPCURecord.query.get(pcu.plc_pcuid)
 152
 153         agg.ports = format_ports(pcu.port_status, pcu.plc_pcu_stats['model'])
 154         agg.status = format_pcu_shortstatus(pcu)
 155
 156         #print pcu.entry_complete
 157         agg.entry_complete_str = pcu.entry_complete
 158         #pcu.entry_complete_str += "".join([ f[0] for f in pcu.entry_complete.split() ])
 159         if pcu.dns_status == "NOHOSTNAME":
 160                 agg.dns_short_status = 'NoHost'
 161         elif pcu.dns_status == "DNS-OK":
 162                 agg.dns_short_status = 'Ok'
 163         elif pcu.dns_status == "DNS-NOENTRY":
 164                 agg.dns_short_status = 'NoEntry'
 165         elif pcu.dns_status == "NO-DNS-OR-IP":
 166                 agg.dns_short_status = 'NoHostOrIP'
 167         elif pcu.dns_status == "DNS-MISMATCH":
 168                 agg.dns_short_status = 'Mismatch'
 169         return agg
 170
 171 class NodeWidget(widgets.Widget):
 172         pass
 173
 174 def prep_nodehist(node):
 175         agg = aggregate()
 176         agg.node = node
 177         agg.loginbase = "unknown"
 178         try:
 179                 agg.loginbase = PlcSite.query.get(node.plc_siteid).plc_site_stats['login_base']
 180         except:
 181                 agg.loginbase = "exception"
 182
 183
 184         return agg
 185
 186 def prep_node_for_display(node, pcuhash=None, preppcu=True, asofdate=None):
 187         agg = aggregate()
 188         agg.node = node
 189
 190         if node.plc_pcuid and preppcu:
 191                 if pcuhash:
 192                         pcu = pcuhash[node.plc_pcuid]
 193                 else:
 194                         pcu = FindbadPCURecord.get_latest_by(plc_pcuid=node.plc_pcuid)
 195
 196                 if pcu:
 197                         agg.pcu_status = pcu.reboot_trial_status
 198                         agg.pcu_short_status = format_pcu_shortstatus(pcu)
 199                         agg.pcu = prep_pcu_for_display(pcu)
 200                 else:
 201                         agg.pcu_short_status = "none"
 202                         agg.pcu_status = "nodata"
 203                         agg.pcu = None
 204
 205         else:
 206                 agg.pcu_status = "nopcu"
 207                 agg.pcu_short_status = "none"
 208                 agg.pcu = None
 209
 210
 211         if node.kernel_version:
 212                 agg.kernel = node.kernel_version.split()[2]
 213         else:
 214                 agg.kernel = ""
 215
 216         try:
 217                 agg.loginbase = PlcSite.query.get(node.plc_node_stats['site_id']).plc_site_stats['login_base']
 218         except:
 219                 agg.loginbase = "unknown"
 220
 221         if agg.loginbase:
 222                 agg.site = HistorySiteRecord.by_loginbase(agg.loginbase)
 223
 224                 if asofdate:
 225                         agg.site = agg.site.get_as_of(asofdate)
 226
 227                 if agg.site is None:
 228                         # TODO: need a cleaner fix for this...
 229                         agg.site = HistorySiteRecord.by_loginbase("pl")
 230                         if not agg.site:
 231                                 agg.site = HistorySiteRecord.by_loginbase("ple")
 232
 233         agg.history = HistoryNodeRecord.by_hostname(node.hostname)
 234         if asofdate:
 235                 agg.history = agg.history.get_as_of(asofdate)
 236
 237         agg.ports = format_ports(node.port_status)
 238
 239         try:
 240                 exists = node.plc_node_stats['last_contact']
 241         except:
 242                 # TODO: this should not assign to the fb object!
 243                 node.plc_node_stats = {'last_contact' : None}
 244
 245         return agg
 246
 247
 248 class Root(controllers.RootController, MonitorXmlrpcServer):
 249         @expose(template="monitorweb.templates.welcome")
 250         def index(self):
 251                 # log.debug("Happy TurboGears Controller Responding For Duty")
 252                 flash("Welcome To MyOps!")
 253                 return dict(now=time.ctime())
 254
 255         @expose(template="monitorweb.templates.nodelist", allow_json=True)
 256         def node3(self, filter=None):
 257                 nhquery = HistoryNodeRecord.query.all()
 258                 query = []
 259                 for nh in nhquery:
 260                         if filter:
 261                                 if nh.status == filter:
 262                                         query.append(nh)
 263                         else:
 264                                 query.append(nh)
 265
 266                 rquery=[]
 267                 for q in query:
 268                         fb = FindbadNodeRecord.get_latest_by(hostname=q.hostname)
 269                         rquery.append(fb)
 270
 271                 return dict(now=time.ctime(), query=rquery)
 272
 273         @expose(template="monitorweb.templates.nodelist", allow_json=True)
 274         def node2(self, filter=None):
 275                 nhquery = HistoryNodeRecord.query.all()
 276                 query = []
 277                 for nh in nhquery:
 278                         if filter:
 279                                 if nh.status == filter:
 280                                         query.append(nh)
 281                         else:
 282                                 query.append(nh)
 283
 284                 rquery=[]
 285                 for q in query:
 286                         fb = FindbadNodeRecord.get_latest_by(hostname=q.hostname)
 287                         agg = prep_node_for_display(fb)
 288                         rquery.append(agg)
 289
 290                 widget = NodeWidget(template='monitorweb.templates.node_template')
 291                 return dict(now=time.ctime(), query=rquery, nodewidget=widget)
 292
 293         @expose(template="monitorweb.templates.query", allow_json=True)
 294         def query(self, **data):
 295                 query = []
 296
 297                 for k in data:
 298                         print k, data[k]
 299
 300                 fbquery = None
 301
 302                 if 'object' in data and data['object'] == "nodes":
 303                         fbquery = FindbadNodeRecord.get_all_latest()
 304                 elif 'object' in data and data['object'] == "nodehistory":
 305                         hostname = data['nodehistory_hostname']
 306                         data['date_checked'] = 'date_checked'
 307                         fbrecord = FindbadNodeRecord.get_by(hostname=hostname)
 308                         fbquery = fbrecord.versions[-500:]
 309
 310                 if fbquery:
 311                         for node in fbquery:
 312                                 # NOTE: reformat some fields.
 313                                 if type(node) is not type(FindbadNodeRecord):
 314                                         agg = node.__dict__.copy()
 315                                 else:
 316                                         agg = node.to_dict()
 317                                 agg.update(agg['plc_node_stats'])
 318                                 if 'rpmvalue' in data and 'rpms' in data:
 319                                         if agg['rpms']:
 320                                                 rpm_list = agg['rpms'].split()
 321                                                 rpm_list = filter(lambda x: data['rpmvalue'] in x, rpm_list)
 322                                                 agg['rpms'] = " ".join(rpm_list)
 323
 324                                 query.append(agg)
 325
 326                 fields=data.copy()
 327
 328                 try:
 329                         del fields['object']
 330                         del fields['rpmvalue']
 331                         del fields['nodehistory_hostname']
 332                 except: pass
 333                 return dict(now=time.ctime(), query=query, fields=fields, data=data, queryform=getNodeQueryForm())
 334
 335         @expose(template="monitorweb.templates.nodefast", allow_json=True)
 336         def node(self, filter=None):
 337                 nhquery = HistoryNodeRecord.query.all()
 338                 query = []
 339                 for nh in nhquery:
 340                         if filter:
 341                                 if nh.status == filter:
 342                                         agg = prep_nodehist(nh)
 343                                         query.append(agg)
 344                         else:
 345                                 agg = prep_nodehist(nh)
 346                                 query.append(agg)
 347
 348                 return dict(now=time.ctime(), query=query)
 349
 350         @expose(template="monitorweb.templates.nodelist")
 351         def nodeslow(self, filter='boot'):
 352                 print "NODE------------------"
 353                 print "befor-len: ", len( [ i for i in session] )
 354                 session.flush(); session.clear()
 355                 print "after-len: ", len( [ i for i in session] )
 356                 fbquery = FindbadNodeRecord.get_all_latest()
 357                 query = []
 358                 filtercount = {'down' : 0, 'boot': 0, 'debug' : 0, 'diagnose' : 0, 'disabled': 0,
 359                                                 'neverboot' : 0, 'pending' : 0, 'all' : 0, None : 0}
 360                 for node in fbquery:
 361                         # NOTE: reformat some fields.
 362                         agg = prep_node_for_display(node)
 363
 364                         if not agg.history:
 365                                 continue
 366
 367                         if agg.history.status in ['down', 'offline']:
 368                                 if node.plc_node_stats and node.plc_node_stats['last_contact'] != None:
 369                                         filtercount['down'] += 1
 370                                 else:
 371                                         filtercount['neverboot'] += 1
 372                         elif agg.history.status in ['good', 'online']:
 373                                 filtercount['boot'] += 1
 374                         elif agg.history.status in ['debug', 'monitordebug']:
 375                                 filtercount['debug'] += 1
 376                         else:
 377                                 if filtercount.has_key(agg.history.status):
 378                                         filtercount[agg.history.status] += 1
 379
 380
 381                         # NOTE: apply filter
 382                         if filter == "neverboot":
 383                                 if not node.plc_node_stats or node.plc_node_stats['last_contact'] == None:
 384                                         query.append(agg)
 385                         elif filter == "all":
 386                                 query.append(agg)
 387                         elif filter == agg.history.status:
 388                                 query.append(agg)
 389                         elif filter == 'boot':
 390                                 query.append(agg)
 391
 392
 393                 widget = NodeWidget(template='monitorweb.templates.node_template')
 394                 return dict(now=time.ctime(), query=query, fc=filtercount, nodewidget=widget)
 395
 396         def nodeaction_handler(self, tg_exceptions=None):
 397                 """Handle any kind of error."""
 398                 print "NODEACTION_HANDLER------------------"
 399
 400                 if 'pcuid' in request.params:
 401                         pcuid = request.params['pcuid']
 402                 else:
 403                         refurl = request.headers.get("Referer",link("pcu"))
 404                         print refurl
 405
 406                         # TODO: do this more intelligently...
 407                         uri_fields = urllib.splitquery(refurl)
 408                         if uri_fields[1] is not None:
 409                                 val = query_to_dict(uri_fields[1])
 410                                 if 'pcuid' in val:
 411                                         pcuid = val['pcuid']
 412                                 elif 'hostname' in val:
 413                                         pcuid = FindbadNodeRecord.get_latest_by(hostname=val['hostname']).plc_pcuid
 414                                 else:
 415                                         pcuid=None
 416                         else:
 417                                 pcuid=None
 418
 419                 cherry_trail = cherrypy._cputil.get_object_trail()
 420                 for i in cherry_trail:
 421                         print "trail: ", i
 422
 423                 print pcuid
 424                 return self.pcuview(None, pcuid, **dict(exceptions=tg_exceptions))
 425
 426         def nodeaction(self, **data):
 427                 print "NODEACTION------------------"
 428                 for item in data.keys():
 429                         print "%s %s" % ( item, data[item] )
 430
 431                 if 'hostname' in data:
 432                         hostname = data['hostname']
 433                 else:
 434                         flash("No hostname given in submitted data")
 435                         return
 436
 437                 if 'submit' in data or 'type' in data:
 438                         try:
 439                                 action = data['submit']
 440                         except:
 441                                 action = data['type']
 442                 else:
 443                         flash("No submit action given in submitted data")
 444                         return
 445
 446                 if action == "Reboot":
 447                         print "REBOOT: %s" % hostname
 448                         ret = reboot.reboot_str(str(hostname))
 449                         print ret
 450                         if ret: raise RuntimeError("Error using PCU: " + str(ret))
 451                         flash("Reboot appeared to work.  Allow at most 5 minutes.  Then run ExternalScan to check current status.")
 452
 453                 elif action == "ExternalScan":
 454                         scanapi.externalprobe(str(hostname))
 455                         flash("External Scan Successful!")
 456                 elif action == "InternalScan":
 457                         scanapi.internalprobe(str(hostname))
 458                         flash("Internal Scan Successful!")
 459                 else:
 460                         # unknown action
 461                         raise RuntimeError("Unknown action given")
 462                 return
 463
 464         @expose(template="monitorweb.templates.simpleview")
 465         def simpleview(self, **data):
 466                 return self.pre_view(**data)
 467
 468         @expose(template="monitorweb.templates.detailview")
 469         def detailview(self, **data):
 470                 return self.pre_view(**data)
 471
 472         def pre_view(self, **data):
 473                 session.flush(); session.clear()
 474
 475                 loginbase=None
 476                 loginbase_list=[]
 477                 hostname=None
 478                 pcuid=None
 479                 since=20
 480                 # if objtype is not None, then treat 'hostname' or 'loginbase' as a search pattern
 481                 objtype=None
 482
 483                 exceptions = None
 484                 sitequery=[]
 485                 nodequery=[]
 486                 pcuquery=[]
 487                 actions=[]
 488                 actions_list=[]
 489
 490                 for key in data:
 491                         print key, data[key]
 492
 493                 if 'query' in data:
 494                         obj = data['query']
 495                         fields = obj.split(":")
 496                         if len(fields) > 1:
 497                                 objtype = fields[0]
 498                                 obj = fields[1].replace("*", "%")
 499                                 print "obj: %s"% obj
 500
 501                         if len(obj.split(".")) > 1 or objtype == "node":
 502                                 hostname = obj
 503                         else:
 504                                 loginbase = obj
 505
 506                 if 'loginbase' in data:
 507                         loginbase = data['loginbase']
 508
 509                 if 'hostname' in data:
 510                         hostname = data['hostname']
 511
 512                 if 'pcuid' in data:
 513                         try: pcuid = int(data['pcuid'])
 514                         except: pcuid = None
 515
 516                 if 'since' in data:
 517                         try: since = int(since)
 518                         except: since = 20
 519
 520                 if pcuid:
 521                         print "pcuid: %s" % pcuid
 522                         pcu = FindbadPCURecord.get_latest_by(plc_pcuid=pcuid)
 523                         loginbase_list += [ PlcSite.query.get(pcu.plc_pcu_stats['site_id']).plc_site_stats['login_base'] ]
 524
 525                 if hostname:
 526                         if not objtype:
 527                                 nodes = [ FindbadNodeRecord.get_latest_by(hostname=hostname) ]
 528                         else:
 529                                 nodes = FindbadNodeRecord.query.filter(FindbadNodeRecord.hostname.like(hostname))
 530
 531                         for node in nodes:
 532                                 lb = PlcSite.query.get(node.plc_node_stats['site_id']).plc_site_stats['login_base']
 533                                 if lb not in loginbase_list:
 534                                         loginbase_list += [ lb ]
 535
 536                 if loginbase:
 537                         if not objtype:
 538                                 loginbase_list = [ loginbase ]
 539                         else:
 540                                 loginbase_list = HistorySiteRecord.query.filter(HistorySiteRecord.loginbase.like(loginbase))
 541                                 loginbase_list = [ l.loginbase for l in loginbase_list ]
 542
 543
 544                 if loginbase_list:
 545                         for loginbase in loginbase_list:
 546                                 actions = ActionRecord.query.filter_by(loginbase=loginbase
 547                                                                 ).filter(ActionRecord.date_created >= datetime.now() - timedelta(since)
 548                                                                 ).order_by(ActionRecord.date_created.desc())
 549                                 actions_list += [ a for a in actions ]
 550                                 site = HistorySiteRecord.by_loginbase(loginbase)
 551                                 if site:
 552                                         sitequery.append(site)
 553                                 # NOTE: because a single pcu may be assigned to multiple hosts,
 554                                 # track unique pcus by their plc_pcuid, then turn dict into list
 555                                 pcus = {}
 556                                 for node in FindbadNodeRecord.query.filter_by(loginbase=loginbase):
 557                                                 # NOTE: reformat some fields.
 558                                                 agg = prep_node_for_display(node)
 559                                                 nodequery += [agg]
 560                                                 if agg.pcu:
 561                                                         pcus[agg.pcu.pcu.plc_pcuid] = agg.pcu
 562
 563                                 for pcuid_key in pcus:
 564                                         pcuquery += [pcus[pcuid_key]]
 565
 566                 return dict(sitequery=sitequery, pcuquery=pcuquery, nodequery=nodequery, actions=actions_list, since=since, exceptions=exceptions)
 567
 568
 569         # TODO: add form validation
 570         @expose(template="monitorweb.templates.pcuview")
 571         @exception_handler(nodeaction_handler,"isinstance(tg_exceptions,RuntimeError)")
 572         def pcuview(self, loginbase=None, pcuid=None, hostname=None, since=20, **data):
 573                 session.flush(); session.clear()
 574                 sitequery=[]
 575                 pcuquery=[]
 576                 nodequery=[]
 577                 actions=[]
 578                 exceptions = None
 579
 580                 try: since = int(since)
 581                 except: since = 7
 582
 583                 for key in data:
 584                         print key, data[key]
 585
 586                 if 'submit' in data.keys() or 'type' in data.keys():
 587                         if hostname: data['hostname'] = hostname
 588                         self.nodeaction(**data)
 589                 if 'exceptions' in data:
 590                         exceptions = data['exceptions']
 591
 592                 if 'query' in data:
 593                         obj = data['query']
 594                         if len(obj.split(".")) > 1: hostname = obj
 595                         else: loginbase=obj
 596
 597                 if pcuid:
 598                         print "pcuid: %s" % pcuid
 599                         pcu = FindbadPCURecord.get_latest_by(plc_pcuid=pcuid)
 600                         loginbase = PlcSite.query.get(pcu.plc_pcu_stats['site_id']).plc_site_stats['login_base']
 601
 602                 if hostname:
 603                         node = FindbadNodeRecord.get_latest_by(hostname=hostname)
 604                         loginbase = PlcSite.query.get(node.plc_node_stats['site_id']).plc_site_stats['login_base']
 605
 606                 if loginbase:
 607                         actions = ActionRecord.query.filter_by(loginbase=loginbase
 608                                                         ).filter(ActionRecord.date_created >= datetime.now() - timedelta(since)
 609                                                         ).order_by(ActionRecord.date_created.desc())
 610                         actions = [ a for a in actions ]
 611                         sitequery = [HistorySiteRecord.by_loginbase(loginbase)]
 612                         pcus = {}
 613                         for node in FindbadNodeRecord.query.filter_by(loginbase=loginbase):
 614                                         # NOTE: reformat some fields.
 615                                         agg = prep_node_for_display(node)
 616                                         nodequery += [agg]
 617                                         if agg.pcu: #.pcu.plc_pcuid:    # not None
 618                                                 #pcu = FindbadPCURecord.get_latest_by(plc_pcuid=agg.plc_pcuid)
 619                                                 #prep_pcu_for_display(pcu)
 620                                                 pcus[agg.pcu.pcu.plc_pcuid] = agg.pcu
 621
 622                         for pcuid_key in pcus:
 623                                 pcuquery += [pcus[pcuid_key]]
 624
 625                 return dict(sitequery=sitequery, pcuquery=pcuquery, nodequery=nodequery, actions=actions, since=since, exceptions=exceptions)
 626
 627         @expose(template="monitorweb.templates.pcuhistory")
 628         def pcuhistory(self, pcu_id=None):
 629                 query = []
 630                 if pcu_id:
 631                         fbnode = HistoryPCURecord.get_by(plc_pcuid=pcu_id)
 632                         l = fbnode.versions[-100:]
 633                         l.reverse()
 634                         for pcu in l:
 635                                 #prep_node_for_display(node)
 636                                 query.append(pcu)
 637
 638                 return dict(query=query, pcu_id=pcu_id)
 639
 640         @expose(template="monitorweb.templates.nodescanhistory")
 641         def nodescanhistory(self, hostname=None, length=10):
 642                 try: length = int(length)
 643                 except: length = 21
 644
 645                 fbnode = FindbadNodeRecord.get_by(hostname=hostname)
 646                 # TODO: add links for earlier history if desired.
 647                 l = fbnode.versions[-length:]
 648                 l.reverse()
 649                 query=[]
 650                 for node in l:
 651                         agg = prep_node_for_display(node, pcuhash=None, preppcu=False, asofdate=node.timestamp)
 652                         query.append(agg)
 653
 654                 if 'length' in request.params:
 655                         del request.params['length']
 656                 return dict(query=query, hostname=hostname, params=request.params)
 657
 658         @expose(template="monitorweb.templates.nodehistory")
 659         def nodehistory(self, hostname=None):
 660                 query = []
 661                 if hostname:
 662                         fbnode = HistoryNodeRecord.get_by(hostname=hostname)
 663                         l = fbnode.versions[-100:]
 664                         l.reverse()
 665                         for node in l:
 666                                 #prep_node_for_display(node)
 667                                 query.append(node)
 668
 669                 return dict(query=query, hostname=hostname)
 670
 671         @expose(template="monitorweb.templates.sitehistory")
 672         def sitehistory(self, loginbase=None):
 673                 query = []
 674                 if loginbase:
 675                         fbsite = HistorySiteRecord.get_by(loginbase=loginbase)
 676                         # TODO: add links for earlier history if desired.
 677                         l = fbsite.versions[-100:]
 678                         l.reverse()
 679                         for site in l:
 680                                 query.append(site)
 681                 return dict(query=query, loginbase=loginbase)
 682
 683
 684         @expose(template="monitorweb.templates.pculist")
 685         def pcu(self, filter='all'):
 686                 print "PCUVIEW------------------"
 687                 print "befor-len: ", len( [ i for i in session] )
 688                 session.flush(); session.clear()
 689                 print "after-len: ", len( [ i for i in session] )
 690                 fbquery = FindbadPCURecord.get_all_latest()
 691                 query = []
 692                 filtercount = {'ok' : 0, 'NetDown': 0, 'Not_Run' : 0, 'pending' : 0, 'all' : 0}
 693                 for node in fbquery:
 694
 695                         # NOTE: count filter
 696                         if node.reboot_trial_status == str(0):
 697                                 filtercount['ok'] += 1
 698                         elif node.reboot_trial_status == 'NetDown' or node.reboot_trial_status == 'Not_Run':
 699                                 filtercount[node.reboot_trial_status] += 1
 700                         else:
 701                                 filtercount['pending'] += 1
 702
 703                         pcuagg = prep_pcu_for_display(node)
 704
 705                         # NOTE: apply filter
 706                         if filter == "all":
 707                                 query.append(pcuagg)
 708                         elif filter == "ok" and node.reboot_trial_status == str(0):
 709                                 query.append(pcuagg)
 710                         elif filter == node.reboot_trial_status:
 711                                 query.append(pcuagg)
 712                         elif filter == "pending":
 713                                 # TODO: look in message logs...
 714                                 if node.reboot_trial_status != str(0) and \
 715                                         node.reboot_trial_status != 'NetDown' and \
 716                                         node.reboot_trial_status != 'Not_Run':
 717
 718                                         query.append(pcuagg)
 719
 720                 return dict(query=query, fc=filtercount)
 721
 722         @expose(template="monitorweb.templates.sitelist")
 723         def site(self, filter='all'):
 724                 print "SITE------------------"
 725                 print "befor-len: ", len( [ i for i in session] )
 726                 session.flush(); session.clear()
 727                 print "after-len: ", len( [ i for i in session] )
 728                 filtercount = {'good' : 0, 'down': 0, 'online':0, 'offline' : 0, 'new' : 0, 'pending' : 0, 'all' : 0}
 729                 fbquery = HistorySiteRecord.query.all()
 730                 query = []
 731                 for site in fbquery:
 732                         # count filter
 733                         filtercount['all'] += 1
 734                         if site.new and site.slices_used == 0 and not site.enabled:
 735                                 filtercount['new'] += 1
 736                         elif not site.enabled:
 737                                 filtercount['pending'] += 1
 738                         elif site.status in ['good', 'online']:
 739                                 filtercount['good'] += 1
 740                         elif site.status in ['down', 'offline']:
 741                                 filtercount['down'] += 1
 742
 743                         # apply filter
 744                         if filter == "all":
 745                                 query.append(site)
 746                         elif filter == 'new' and site.new and site.slices_used == 0 and not site.enabled:
 747                                 query.append(site)
 748                         elif filter == "pending" and not site.enabled:
 749                                 query.append(site)
 750                         elif filter == 'good' and site.status in ['good', 'online']:
 751                                 query.append(site)
 752                         elif filter == 'down' and site.status in ['down', 'offline']:
 753                                 query.append(site)
 754
 755                 return dict(query=query, fc=filtercount)
 756         @expose(template="monitorweb.templates.sitesummary")
 757         def sitesummary(self, loginbase="princeton"):
 758                 nodequery = []
 759                 for node in FindbadNodeRecord.query.filter_by(loginbase=loginbase):
 760                         agg = prep_node_for_display(node)
 761                         nodequery += [agg]
 762
 763                 return dict(nodequery=nodequery, loginbase=loginbase)
 764
 765         @expose(template="monitorweb.templates.summary")
 766         def summary(self, since=7):
 767                 sumdata = {}
 768                 sumdata['nodes'] = {}
 769                 sumdata['sites'] = {}
 770                 sumdata['pcus'] = {}
 771
 772                 def summarize(query, type):
 773                         for o in query:
 774                                 if o.status not in sumdata[type]:
 775                                         sumdata[type][o.status] = 0
 776                                 sumdata[type][o.status] += 1
 777
 778                 fbquery = HistorySiteRecord.query.all()
 779                 summarize(fbquery, 'sites')
 780                 fbquery = HistoryPCURecord.query.all()
 781                 summarize(fbquery, 'pcus')
 782                 fbquery = HistoryNodeRecord.query.all()
 783                 summarize(fbquery, 'nodes')
 784
 785                 if 'monitordebug' in sumdata['nodes']:
 786                         d = sumdata['nodes']['monitordebug']
 787                         del sumdata['nodes']['monitordebug']
 788                         sumdata['nodes']['failboot'] = d
 789
 790                 return dict(sumdata=sumdata, setorder=['good', 'offline', 'down', 'online'])
 791
 792         @expose(template="monitorweb.templates.actionsummary")
 793         def actionsummary(self, since=7):
 794                 from monitor.wrapper.emailTxt import mailtxt
 795
 796                 types = filter(lambda x: 'notice' in x, dir(mailtxt))
 797                 results = {}
 798
 799                 try: since = int(since)
 800                 except: since = 7
 801
 802                 for  t in types:
 803                         acts = ActionRecord.query.filter(ActionRecord.action_type==t
 804                                         ).filter(ActionRecord.date_created >= datetime.now() - timedelta(since))
 805                         results[t] = acts.count()
 806                 return dict(results=results)
 807
 808         @expose(template="monitorweb.templates.actionlist")
 809         def actionlist(self, action_type='down_notice', since=7, loginbase=None):
 810
 811                 try: since = int(since)
 812                 except: since = 7
 813
 814                 if loginbase:
 815                         acts = ActionRecord.query.filter_by(loginbase=loginbase
 816                                 ).filter(ActionRecord.date_created >= datetime.now() - timedelta(since)
 817                                 ).order_by(ActionRecord.date_created.desc())
 818                 else:
 819                         acts = ActionRecord.query.filter(ActionRecord.action_type==action_type
 820                                 ).filter(ActionRecord.date_created >= datetime.now() - timedelta(since)
 821                                 ).order_by(ActionRecord.date_created.desc())
 822                 query = [ a for a in acts ]
 823
 824                 return dict(actions=query, action_type=action_type, since=since)