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         nm_status = Field(String,default=None)
  42         fs_status = Field(String,default=None)
  43         iptables_status = Field(String,default=None)
  44         dns_status = Field(String,default=None)
  45         external_dns_status = Field(Boolean,default=True)
  46         uptime = Field(String,default=None)
  47         rpms = Field(String,default=None)
  48         princeton_comon_dir = Field(Boolean,default=False)
  49         princeton_comon_running = Field(Boolean,default=False)
  50         princeton_comon_procs = Field(Int,default=None)
  51
  52 # EXTERNAL
  53         plc_node_stats = Field(PickleType,default=None)
  54         plc_site_stats = Field(PickleType,default=None)
  55         plc_pcuid      = Field(Int,default=None)
  56         comon_stats    = Field(PickleType,default=None)
  57         port_status    = Field(PickleType,default=None)
  58         firewall                = Field(Boolean,default=False)
  59         ssh_portused = Field(Int,default=22)
  60         ssh_status = Field(Boolean,default=False)
  61         ssh_error = Field(String,default=None)  # set if ssh_access == False
  62         traceroute = Field(String,default=None)
  63         ping_status = Field(Boolean,default=False)
  64
  65 # INFERRED
  66         observed_category = Field(String,default=None)
  67         observed_status = Field(String,default=None)
  68
  69         acts_as_versioned(ignore=['date_checked'])
  70         # NOTE: this is the child relation
  71         #action = ManyToOne('ActionRecord', required=False)
  72
  73 class FindbadPCURecord(Entity):
  74         @classmethod
  75         def get_all_latest(cls):
  76                 return cls.query.all()
  77
  78         @classmethod
  79         def get_latest_by(cls, **kwargs):
  80                 return cls.query.filter_by(**kwargs).first()
  81
  82         def pcu_name(self):
  83                 if self.plc_pcu_stats['hostname'] is not None and self.plc_pcu_stats['hostname'] is not "":
  84                         return self.plc_pcu_stats['hostname']
  85                 elif self.plc_pcu_stats['ip'] is not None and self.plc_pcu_stats['ip'] is not "":
  86                         return self.plc_pcu_stats['ip']
  87                 else:
  88                         return None
  89
  90         def format_ports(self):
  91                 retval = []
  92                 filtered_length=0
  93
  94                 supported_ports=reboot.model_to_object(self.plc_pcu_stats['model']).supported_ports
  95                 data = self.port_status.copy()
  96
  97                 if data and len(data.keys()) > 0 :
  98                         for port in supported_ports:
  99                                 try:
 100                                         state = data[str(port)]
 101                                 except:
 102                                         state = "unknown"
 103
 104                                 if state == "filtered":
 105                                         filtered_length += 1
 106
 107                                 retval.append( (port, state) )
 108
 109                 if retval == []:
 110                         retval = [( "Closed/Filtered", "" )]
 111
 112                 if filtered_length == len(supported_ports):
 113                         retval = [( "All Filtered", "" )]
 114
 115                 return retval
 116
 117         def format_pcu_shortstatus(self):
 118                 status = "error"
 119                 if self.reboot_trial_status:
 120                         if self.reboot_trial_status == str(0):
 121                                 status = "Ok"
 122                         elif self.reboot_trial_status == "NetDown" or self.reboot_trial_status == "Not_Run":
 123                                 status = self.reboot_trial_status
 124                         else:
 125                                 status = "error"
 126
 127                 return status
 128
 129         def test_is_ok(self):
 130                 if self.reboot_trial_status == str(0):
 131                         return True
 132                 else:
 133                         return False
 134
 135         def pcu_errors(self):
 136                 message = "\n"
 137                 message += "\tModel: %s\n" % self.plc_pcu_stats['model']
 138                 message += "\tMissing Fields: %s\n" % ( self.entry_complete == "" and "None missing" or self.entry_complete )
 139                 message += "\tDNS Status: %s\n" % self.dns_status
 140                 message += "\tPort Status: %s\n" % self.format_ports()
 141                 message += "\tTest Results: %s\n" % self.format_pcu_shortstatus()
 142                 return message
 143
 144 # ACCOUNTING
 145         date_checked = Field(DateTime)
 146         round = Field(Int,default=0)
 147         plc_pcuid = Field(Int)
 148
 149 # EXTERNAL
 150         plc_pcu_stats = Field(PickleType,default=None)
 151         dns_status = Field(String)
 152         port_status = Field(PickleType)
 153         entry_complete = Field(String)
 154
 155 # INTERNAL
 156 # INFERRED
 157         reboot_trial_status = Field(String)
 158
 159         acts_as_versioned(ignore=['date_checked'])