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