monitor/database/info/findbad.py

   1 from elixir import Entity, Field, OneToMany, ManyToOne, ManyToMany
   2 from elixir import options_defaults, using_options, setup_all, belongs_to
   3 from elixir import String, Integer as Int, DateTime, PickleType, Boolean
   4 from datetime import datetime,timedelta
   5 import elixir
   6 import traceback
   7 from elixir.ext.versioned import *
   8 from pcucontrol import reboot
   9
  10 from monitor.database.dborm import mon_metadata, mon_session
  11 __metadata__ = mon_metadata
  12 __session__  = mon_session
  13
  14
  15 class FindbadNodeRecord(Entity):
  16         @classmethod
  17         def get_all_latest(cls):
  18                 return cls.query.all()
  19
  20         @classmethod
  21         def get_latest_by(cls, **kwargs):
  22                 return cls.query.filter_by(**kwargs).first()
  23
  24         @classmethod
  25         def get_latest_by(cls, **kwargs):
  26                 return cls.query.filter_by(**kwargs).first()
  27
  28         @classmethod
  29         def get_latest_n_by(cls, n=3, **kwargs):
  30                 return cls.query.filter_by(**kwargs)
  31
  32 # ACCOUNTING
  33         date_checked = Field(DateTime,default=datetime.now)
  34         round = Field(Int,default=0)
  35         hostname = Field(String,primary_key=True,default=None)
  36         loginbase = Field(String)
  37
  38 # INTERNAL
  39         kernel_version = Field(String,default=None)
  40         bootcd_version = Field(String,default=None)
  41         boot_server = Field(String,default=None)
  42         nm_status = Field(String,default=None)
  43         fs_status = Field(String,default=None)
  44         iptables_status = Field(String,default=None)
  45         dns_status = Field(String,default=None)
  46         external_dns_status = Field(Boolean,default=True)
  47         uptime = Field(String,default=None)
  48         rpms = Field(String,default=None)
  49         princeton_comon_dir = Field(Boolean,default=False)
  50         princeton_comon_running = Field(Boolean,default=False)
  51         princeton_comon_procs = Field(Int,default=None)
  52
  53 # EXTERNAL
  54         plc_node_stats = Field(PickleType,default=None)
  55         plc_site_stats = Field(PickleType,default=None)
  56         plc_pcuid      = Field(Int,default=None)
  57         comon_stats    = Field(PickleType,default=None)
  58         port_status    = Field(PickleType,default=None)
  59         firewall                = Field(Boolean,default=False)
  60         ssh_portused = Field(Int,default=22)
  61         ssh_status = Field(Boolean,default=False)
  62         ssh_error = Field(String,default=None)  # set if ssh_access == False
  63         traceroute = Field(String,default=None)
  64         ping_status = Field(Boolean,default=False)
  65
  66 # INFERRED
  67         observed_category = Field(String,default=None)
  68         observed_status = Field(String,default=None)
  69
  70         acts_as_versioned(ignore=['date_checked'])
  71         # NOTE: this is the child relation
  72         #action = ManyToOne('ActionRecord', required=False)
  73
  74 class FindbadPCURecord(Entity):
  75         @classmethod
  76         def get_all_latest(cls):
  77                 return cls.query.all()
  78
  79         @classmethod
  80         def get_latest_by(cls, **kwargs):
  81                 return cls.query.filter_by(**kwargs).first()
  82
  83         def pcu_name(self):
  84                 if self.plc_pcu_stats['hostname'] is not None and self.plc_pcu_stats['hostname'] is not "":
  85                         return self.plc_pcu_stats['hostname']
  86                 elif self.plc_pcu_stats['ip'] is not None and self.plc_pcu_stats['ip'] is not "":
  87                         return self.plc_pcu_stats['ip']
  88                 else:
  89                         return None
  90
  91         def format_ports(self):
  92                 retval = []
  93                 filtered_length=0
  94
  95                 supported_ports=reboot.model_to_object(self.plc_pcu_stats['model']).supported_ports
  96                 data = self.port_status.copy()
  97
  98                 if data and len(data.keys()) > 0 :
  99                         for port in supported_ports:
 100                                 try:
 101                                         state = data[str(port)]
 102                                 except:
 103                                         state = "unknown"
 104
 105                                 if state == "filtered":
 106                                         filtered_length += 1
 107
 108                                 retval.append( (port, state) )
 109
 110                 if retval == []:
 111                         retval = [( "Closed/Filtered", "" )]
 112
 113                 if filtered_length == len(supported_ports):
 114                         retval = [( "All Filtered", "" )]
 115
 116                 return retval
 117
 118         def format_pcu_shortstatus(self):
 119                 status = "error"
 120                 if self.reboot_trial_status:
 121                         if self.reboot_trial_status == str(0):
 122                                 status = "Ok"
 123                         elif self.reboot_trial_status == "NetDown" or self.reboot_trial_status == "Not_Run":
 124                                 status = self.reboot_trial_status
 125                         else:
 126                                 status = "error"
 127
 128                 return status
 129
 130         def test_is_ok(self):
 131                 if self.reboot_trial_status == str(0):
 132                         return True
 133                 else:
 134                         return False
 135
 136         def pcu_errors(self):
 137                 message = "\n"
 138                 message += "\tModel: %s\n" % self.plc_pcu_stats['model']
 139                 message += "\tMissing Fields: %s\n" % ( self.entry_complete == "" and "None missing" or self.entry_complete )
 140                 message += "\tDNS Status: %s\n" % self.dns_status
 141                 message += "\tPort Status: %s\n" % self.format_ports()
 142                 message += "\tTest Results: %s\n" % self.format_pcu_shortstatus()
 143                 return message
 144
 145 # ACCOUNTING
 146         date_checked = Field(DateTime)
 147         round = Field(Int,default=0)
 148         plc_pcuid = Field(Int)
 149
 150 # EXTERNAL
 151         plc_pcu_stats = Field(PickleType,default=None)
 152         dns_status = Field(String)
 153         port_status = Field(PickleType)
 154         entry_complete = Field(String)
 155
 156 # INTERNAL
 157 # INFERRED
 158         reboot_trial_status = Field(String)
 159
 160         acts_as_versioned(ignore=['date_checked'])