gAlert.py

Go to the documentation of this file.

#!/usr/local/bin/python
#
#                               Copyright 2005
#                                     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__     = "2004/03/09 00:00:00"
__updated__  = "$Date: 2005/09/22 00:29:31 $"
__version__  = "$Revision: 1.5 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

# Python imports
import logging
import re
import time

# LICOS imports
import 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):
    """!\brief 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):
  """!\brief 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):
    """!\brief 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):
    """!\brief Method to decode an alert string dispatched to the message logger.

    \param string String to be decoded

    \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):
  """!\brief Alert registry class.

  """
  def __init__(self):
    self.__handlers     = []
    self.__dispatchMap  = {"ALL":[]}
    pass

  def register(self, system, handler):
    """!\brief 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

---