gAlert.py

#!/usr/local/bin/python
#
#                               Copyright 2004
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "GLAST LAT alert email tool"
__author__   = "Jim Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "09/03/2004"
__version__  = "$Revision: 1.5 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

# Python imports
import logging
import re
import time

# LATTE imports
import LATTE.tools.MailAlert as MailAlert

# set up logging
logging.addLevelName(60, 'ALERT')
logging.ALERT = 60

# add alert severity levels
YELLOWALERT  = 10
REDALERT     = 30
alertDict = { YELLOWALERT:"Minor", REDALERT:"Major"}

def alert(message, system, severity=YELLOWALERT, machine=0):
  
  alertStr = gAlertStr()
  
  logging.log(logging.ALERT, alertStr.encode(severity, time.time(), system, message, machine))


class gAlertHandler(object):
  def __init__(self):
    pass
    
  def handle(self, alertStr):
    """ Method to handle an alert
    \param alertStr  a gAlertStr object
    """
    raise NotImplementedError, "call to abstract base class gAlertHandler::handle()"

class gAlertMailer(gAlertHandler):
  def __init__(self, recipient):
    gAlertHandler.__init__(self)
    self.__recipient = recipient
    self.__sender    = "glast@slac.stanford.edu"  # add text for glast alarm acct <...>
    self.__smtp      = MailAlert.SLACmail()
    
  def handle(self, alertStr):
    (severity, timestamp, machine, system, message) = alertStr.decode()
    
    # construct email object
    subject = "[LAT] %s %s %s HOST:%d" % \
              ( system, alertDict[severity], time.asctime(time.gmtime(timestamp)), machine )
    eml = gAlertMail(self.__recipient, subject, message)
    # print "sending email to %s, subj=%s, msg=%s" % (self.__recipient, subject, message)
    self.__smtp.sendMail(eml)

class gAlertStr(object):
  """Parser/unparser/container for alert strings
  """
  def __init__(self, alertStr=None):
    self.__alertFmt = "%04d-%f-%d-%s-%s"
    self.__alertRe  = re.compile("(\d\d\d\d)-([\d\.]+)-([\d]+)-([^-]+)-(.*)")
    self.__string   = alertStr
    
  def encode(self, severity, timestamp, system, message, machine=0):
    """Method to encode an alert string for dispatch to the message logger
    \param severity   Severity level (YELLOWALERT or REDALERT)
    \param time       Time alert was sent
    \param system     System alert was sent from
    \param message    Alert message
    \param machine    Machine ID alert is sent from
    """
    self.__string = self.__alertFmt % (severity, timestamp, machine, system, message)
    return self.__string

  def decode(self, string=None):
    """Method to decode an alert string dispatched to the message logger
    \return  (severity, time, system, message)
    """
    if string==None:
      string = self.__string
    dec = self.__alertRe.split(string)
    # print string, dec
    severity   = int(dec[1])
    timestamp  = float(dec[2])
    machine    = int(dec[3])
    system     = str(dec[4])
    message    = str(dec[5])
    return (severity, timestamp, machine, system, message)
    

class gAlertMail(MailAlert.Email):
  def __init__(self, recip, subject, message):
    MailAlert.Email.__init__(self)
    self.sender("glast@slac.stanford.edu")  # add text for glast alarm acct <...>
    self.recipient(recip)
    self.body("Subject: %s " % subject + "\r\n" + message)
    
    
class gAlertRegistry(object):
  """Alert registry class
  """
  def __init__(self):
    self.__handlers     = []
    self.__dispatchMap  = {"ALL":[]}
    pass
  
  def register(self, system, handler):
    """register method
    \param handler
    \param system
    """
    if handler not in self.__handlers:
      self.__handlers.append(handler)
    system = system.upper()
    if system not in self.__dispatchMap.keys():
      self.__dispatchMap[system] = []
    self.__dispatchMap[system].append(handler)
  
  def unregister(self, handler, categories):
    pass
    
  def handle(self, alertStr):
    (severity, timestamp, machine, system, message) = alertStr.decode()  # just to get system
    
    system = system.upper()
    # if system not in self.__dispatchMap.keys():
      # print "system \'%s\' not in keys" % system, self.__dispatchMap.keys()
      # raise KeyError
      
    # deal with "ALL" and appending handlers
    handleList = self.__dispatchMap["ALL"]
    if system in self.__dispatchMap.keys():
      for handler in self.__dispatchMap[system]:
        if handler not in handleList:
          handleList.append(handler)
    
    for handler in handleList:
      handler.handle(alertStr)
 
    
if __name__ == "__main__":
  
  # create handlers
  h1 = gAlertMailer("panetta@slac.stanford.edu")
  # h1 = gAlertMailer("claus@slac.stanford.edu")
  h2 = gAlertMailer("6508499455@myairmail.com")
  
  h1set = ['CAL', 'LATTE', 'HSK']
  h1list = []
  for s in h1set:
    h1list.append("%8s"%s)
  
  registry = gAlertRegistry()
  # registry.register(h1, h1list)
  registry.register(h1, h1list)
  
  alertStr = gAlertStr()
  alertStr.encode(YELLOWALERT, time.time(), "LATTE", "Ah, I just figured out how to set a subject", 0)
  
  registry.handle(alertStr)
    
    
#EOF

---