home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / logging / handlers.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  22.3 KB  |  830 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import logging
  5. import socket
  6. import types
  7. import os
  8. import string
  9. import cPickle
  10. import struct
  11. import time
  12. import re
  13. from stat import ST_DEV, ST_INO
  14.  
  15. try:
  16.     import codecs
  17. except ImportError:
  18.     codecs = None
  19.  
  20. DEFAULT_TCP_LOGGING_PORT = 9020
  21. DEFAULT_UDP_LOGGING_PORT = 9021
  22. DEFAULT_HTTP_LOGGING_PORT = 9022
  23. DEFAULT_SOAP_LOGGING_PORT = 9023
  24. SYSLOG_UDP_PORT = 514
  25. _MIDNIGHT = 86400
  26.  
  27. class BaseRotatingHandler(logging.FileHandler):
  28.     
  29.     def __init__(self, filename, mode, encoding = None, delay = 0):
  30.         if codecs is None:
  31.             encoding = None
  32.         
  33.         logging.FileHandler.__init__(self, filename, mode, encoding, delay)
  34.         self.mode = mode
  35.         self.encoding = encoding
  36.  
  37.     
  38.     def emit(self, record):
  39.         
  40.         try:
  41.             if self.shouldRollover(record):
  42.                 self.doRollover()
  43.             
  44.             logging.FileHandler.emit(self, record)
  45.         except (KeyboardInterrupt, SystemExit):
  46.             raise 
  47.         except:
  48.             self.handleError(record)
  49.  
  50.  
  51.  
  52.  
  53. class RotatingFileHandler(BaseRotatingHandler):
  54.     
  55.     def __init__(self, filename, mode = 'a', maxBytes = 0, backupCount = 0, encoding = None, delay = 0):
  56.         if maxBytes > 0:
  57.             mode = 'a'
  58.         
  59.         BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
  60.         self.maxBytes = maxBytes
  61.         self.backupCount = backupCount
  62.  
  63.     
  64.     def doRollover(self):
  65.         self.stream.close()
  66.         if self.backupCount > 0:
  67.             for i in range(self.backupCount - 1, 0, -1):
  68.                 sfn = '%s.%d' % (self.baseFilename, i)
  69.                 dfn = '%s.%d' % (self.baseFilename, i + 1)
  70.                 if os.path.exists(sfn):
  71.                     if os.path.exists(dfn):
  72.                         os.remove(dfn)
  73.                     
  74.                     os.rename(sfn, dfn)
  75.                     continue
  76.             
  77.             dfn = self.baseFilename + '.1'
  78.             if os.path.exists(dfn):
  79.                 os.remove(dfn)
  80.             
  81.             os.rename(self.baseFilename, dfn)
  82.         
  83.         self.mode = 'w'
  84.         self.stream = self._open()
  85.  
  86.     
  87.     def shouldRollover(self, record):
  88.         if self.stream is None:
  89.             self.stream = self._open()
  90.         
  91.         if self.maxBytes > 0:
  92.             msg = '%s\n' % self.format(record)
  93.             self.stream.seek(0, 2)
  94.             if self.stream.tell() + len(msg) >= self.maxBytes:
  95.                 return 1
  96.         
  97.         return 0
  98.  
  99.  
  100.  
  101. class TimedRotatingFileHandler(BaseRotatingHandler):
  102.     
  103.     def __init__(self, filename, when = 'h', interval = 1, backupCount = 0, encoding = None, delay = 0, utc = 0):
  104.         BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
  105.         self.when = string.upper(when)
  106.         self.backupCount = backupCount
  107.         self.utc = utc
  108.         currentTime = int(time.time())
  109.         if self.when == 'S':
  110.             self.interval = 1
  111.             self.suffix = '%Y-%m-%d_%H-%M-%S'
  112.             self.extMatch = '^\\d{4}-\\d{2}-\\d{2}_\\d{2}-\\d{2}-\\d{2}$'
  113.         elif self.when == 'M':
  114.             self.interval = 60
  115.             self.suffix = '%Y-%m-%d_%H-%M'
  116.             self.extMatch = '^\\d{4}-\\d{2}-\\d{2}_\\d{2}-\\d{2}$'
  117.         elif self.when == 'H':
  118.             self.interval = 3600
  119.             self.suffix = '%Y-%m-%d_%H'
  120.             self.extMatch = '^\\d{4}-\\d{2}-\\d{2}_\\d{2}$'
  121.         elif self.when == 'D' or self.when == 'MIDNIGHT':
  122.             self.interval = 86400
  123.             self.suffix = '%Y-%m-%d'
  124.             self.extMatch = '^\\d{4}-\\d{2}-\\d{2}$'
  125.         elif self.when.startswith('W'):
  126.             self.interval = 604800
  127.             if len(self.when) != 2:
  128.                 raise ValueError('You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s' % self.when)
  129.             len(self.when) != 2
  130.             if self.when[1] < '0' or self.when[1] > '6':
  131.                 raise ValueError('Invalid day specified for weekly rollover: %s' % self.when)
  132.             self.when[1] > '6'
  133.             self.dayOfWeek = int(self.when[1])
  134.             self.suffix = '%Y-%m-%d'
  135.             self.extMatch = '^\\d{4}-\\d{2}-\\d{2}$'
  136.         else:
  137.             raise ValueError('Invalid rollover interval specified: %s' % self.when)
  138.         self.extMatch = (self.when == 'MIDNIGHT').compile(self.extMatch)
  139.         self.interval = self.interval * interval
  140.         self.rolloverAt = currentTime + self.interval
  141.         if self.when == 'MIDNIGHT' or self.when.startswith('W'):
  142.             if utc:
  143.                 t = time.gmtime(currentTime)
  144.             else:
  145.                 t = time.localtime(currentTime)
  146.             currentHour = t[3]
  147.             currentMinute = t[4]
  148.             currentSecond = t[5]
  149.             r = _MIDNIGHT - ((currentHour * 60 + currentMinute) * 60 + currentSecond)
  150.             self.rolloverAt = currentTime + r
  151.             if when.startswith('W'):
  152.                 day = t[6]
  153.                 if day != self.dayOfWeek:
  154.                     if day < self.dayOfWeek:
  155.                         daysToWait = self.dayOfWeek - day
  156.                     else:
  157.                         daysToWait = (6 - day) + self.dayOfWeek + 1
  158.                     newRolloverAt = self.rolloverAt + daysToWait * 86400
  159.                     if not utc:
  160.                         dstNow = t[-1]
  161.                         dstAtRollover = time.localtime(newRolloverAt)[-1]
  162.                         if dstNow != dstAtRollover:
  163.                             if not dstNow:
  164.                                 newRolloverAt = newRolloverAt - 3600
  165.                             else:
  166.                                 newRolloverAt = newRolloverAt + 3600
  167.                         
  168.                     
  169.                     self.rolloverAt = newRolloverAt
  170.                 
  171.             
  172.         
  173.  
  174.     
  175.     def shouldRollover(self, record):
  176.         t = int(time.time())
  177.         if t >= self.rolloverAt:
  178.             return 1
  179.         return 0
  180.  
  181.     
  182.     def getFilesToDelete(self):
  183.         (dirName, baseName) = os.path.split(self.baseFilename)
  184.         fileNames = os.listdir(dirName)
  185.         result = []
  186.         prefix = baseName + '.'
  187.         plen = len(prefix)
  188.         for fileName in fileNames:
  189.             if fileName[:plen] == prefix:
  190.                 suffix = fileName[plen:]
  191.                 if self.extMatch.match(suffix):
  192.                     result.append(os.path.join(dirName, fileName))
  193.                 
  194.             self.extMatch.match(suffix)
  195.         
  196.         result.sort()
  197.         if len(result) < self.backupCount:
  198.             result = []
  199.         else:
  200.             result = result[:len(result) - self.backupCount]
  201.         return result
  202.  
  203.     
  204.     def doRollover(self):
  205.         if self.stream:
  206.             self.stream.close()
  207.         
  208.         t = self.rolloverAt - self.interval
  209.         if self.utc:
  210.             timeTuple = time.gmtime(t)
  211.         else:
  212.             timeTuple = time.localtime(t)
  213.         dfn = self.baseFilename + '.' + time.strftime(self.suffix, timeTuple)
  214.         if os.path.exists(dfn):
  215.             os.remove(dfn)
  216.         
  217.         os.rename(self.baseFilename, dfn)
  218.         if self.backupCount > 0:
  219.             for s in self.getFilesToDelete():
  220.                 os.remove(s)
  221.             
  222.         
  223.         self.mode = 'w'
  224.         self.stream = self._open()
  225.         newRolloverAt = self.rolloverAt + self.interval
  226.         currentTime = int(time.time())
  227.         while newRolloverAt <= currentTime:
  228.             newRolloverAt = newRolloverAt + self.interval
  229.         if (self.when == 'MIDNIGHT' or self.when.startswith('W')) and not (self.utc):
  230.             dstNow = time.localtime(currentTime)[-1]
  231.             dstAtRollover = time.localtime(newRolloverAt)[-1]
  232.             if dstNow != dstAtRollover:
  233.                 if not dstNow:
  234.                     newRolloverAt = newRolloverAt - 3600
  235.                 else:
  236.                     newRolloverAt = newRolloverAt + 3600
  237.             
  238.         
  239.         self.rolloverAt = newRolloverAt
  240.  
  241.  
  242.  
  243. class WatchedFileHandler(logging.FileHandler):
  244.     
  245.     def __init__(self, filename, mode = 'a', encoding = None, delay = 0):
  246.         logging.FileHandler.__init__(self, filename, mode, encoding, delay)
  247.         if not os.path.exists(self.baseFilename):
  248.             (self.dev, self.ino) = (-1, -1)
  249.         else:
  250.             stat = os.stat(self.baseFilename)
  251.             self.dev = stat[ST_DEV]
  252.             self.ino = stat[ST_INO]
  253.  
  254.     
  255.     def emit(self, record):
  256.         if not os.path.exists(self.baseFilename):
  257.             stat = None
  258.             changed = 1
  259.         else:
  260.             stat = os.stat(self.baseFilename)
  261.             if not stat[ST_DEV] != self.dev:
  262.                 pass
  263.             changed = stat[ST_INO] != self.ino
  264.         if changed and self.stream is not None:
  265.             self.stream.flush()
  266.             self.stream.close()
  267.             self.stream = self._open()
  268.             if stat is None:
  269.                 stat = os.stat(self.baseFilename)
  270.             
  271.             self.dev = stat[ST_DEV]
  272.             self.ino = stat[ST_INO]
  273.         
  274.         logging.FileHandler.emit(self, record)
  275.  
  276.  
  277.  
  278. class SocketHandler(logging.Handler):
  279.     
  280.     def __init__(self, host, port):
  281.         logging.Handler.__init__(self)
  282.         self.host = host
  283.         self.port = port
  284.         self.sock = None
  285.         self.closeOnError = 0
  286.         self.retryTime = None
  287.         self.retryStart = 1
  288.         self.retryMax = 30
  289.         self.retryFactor = 2
  290.  
  291.     
  292.     def makeSocket(self, timeout = 1):
  293.         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  294.         if hasattr(s, 'settimeout'):
  295.             s.settimeout(timeout)
  296.         
  297.         s.connect((self.host, self.port))
  298.         return s
  299.  
  300.     
  301.     def createSocket(self):
  302.         now = time.time()
  303.         if self.retryTime is None:
  304.             attempt = 1
  305.         else:
  306.             attempt = now >= self.retryTime
  307.         if attempt:
  308.             
  309.             try:
  310.                 self.sock = self.makeSocket()
  311.                 self.retryTime = None
  312.             except socket.error:
  313.                 if self.retryTime is None:
  314.                     self.retryPeriod = self.retryStart
  315.                 else:
  316.                     self.retryPeriod = self.retryPeriod * self.retryFactor
  317.                     if self.retryPeriod > self.retryMax:
  318.                         self.retryPeriod = self.retryMax
  319.                     
  320.                 self.retryTime = now + self.retryPeriod
  321.             except:
  322.                 None<EXCEPTION MATCH>socket.error
  323.             
  324.  
  325.         None<EXCEPTION MATCH>socket.error
  326.  
  327.     
  328.     def send(self, s):
  329.         if self.sock is None:
  330.             self.createSocket()
  331.         
  332.         if self.sock:
  333.             
  334.             try:
  335.                 if hasattr(self.sock, 'sendall'):
  336.                     self.sock.sendall(s)
  337.                 else:
  338.                     sentsofar = 0
  339.                     left = len(s)
  340.                     while left > 0:
  341.                         sent = self.sock.send(s[sentsofar:])
  342.                         sentsofar = sentsofar + sent
  343.                         left = left - sent
  344.             except socket.error:
  345.                 self.sock.close()
  346.                 self.sock = None
  347.             except:
  348.                 None<EXCEPTION MATCH>socket.error
  349.             
  350.  
  351.         None<EXCEPTION MATCH>socket.error
  352.  
  353.     
  354.     def makePickle(self, record):
  355.         ei = record.exc_info
  356.         if ei:
  357.             dummy = self.format(record)
  358.             record.exc_info = None
  359.         
  360.         s = cPickle.dumps(record.__dict__, 1)
  361.         if ei:
  362.             record.exc_info = ei
  363.         
  364.         slen = struct.pack('>L', len(s))
  365.         return slen + s
  366.  
  367.     
  368.     def handleError(self, record):
  369.         if self.closeOnError and self.sock:
  370.             self.sock.close()
  371.             self.sock = None
  372.         else:
  373.             logging.Handler.handleError(self, record)
  374.  
  375.     
  376.     def emit(self, record):
  377.         
  378.         try:
  379.             s = self.makePickle(record)
  380.             self.send(s)
  381.         except (KeyboardInterrupt, SystemExit):
  382.             raise 
  383.         except:
  384.             self.handleError(record)
  385.  
  386.  
  387.     
  388.     def close(self):
  389.         if self.sock:
  390.             self.sock.close()
  391.             self.sock = None
  392.         
  393.         logging.Handler.close(self)
  394.  
  395.  
  396.  
  397. class DatagramHandler(SocketHandler):
  398.     
  399.     def __init__(self, host, port):
  400.         SocketHandler.__init__(self, host, port)
  401.         self.closeOnError = 0
  402.  
  403.     
  404.     def makeSocket(self):
  405.         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  406.         return s
  407.  
  408.     
  409.     def send(self, s):
  410.         if self.sock is None:
  411.             self.createSocket()
  412.         
  413.         self.sock.sendto(s, (self.host, self.port))
  414.  
  415.  
  416.  
  417. class SysLogHandler(logging.Handler):
  418.     LOG_EMERG = 0
  419.     LOG_ALERT = 1
  420.     LOG_CRIT = 2
  421.     LOG_ERR = 3
  422.     LOG_WARNING = 4
  423.     LOG_NOTICE = 5
  424.     LOG_INFO = 6
  425.     LOG_DEBUG = 7
  426.     LOG_KERN = 0
  427.     LOG_USER = 1
  428.     LOG_MAIL = 2
  429.     LOG_DAEMON = 3
  430.     LOG_AUTH = 4
  431.     LOG_SYSLOG = 5
  432.     LOG_LPR = 6
  433.     LOG_NEWS = 7
  434.     LOG_UUCP = 8
  435.     LOG_CRON = 9
  436.     LOG_AUTHPRIV = 10
  437.     LOG_LOCAL0 = 16
  438.     LOG_LOCAL1 = 17
  439.     LOG_LOCAL2 = 18
  440.     LOG_LOCAL3 = 19
  441.     LOG_LOCAL4 = 20
  442.     LOG_LOCAL5 = 21
  443.     LOG_LOCAL6 = 22
  444.     LOG_LOCAL7 = 23
  445.     priority_names = {
  446.         'alert': LOG_ALERT,
  447.         'crit': LOG_CRIT,
  448.         'critical': LOG_CRIT,
  449.         'debug': LOG_DEBUG,
  450.         'emerg': LOG_EMERG,
  451.         'err': LOG_ERR,
  452.         'error': LOG_ERR,
  453.         'info': LOG_INFO,
  454.         'notice': LOG_NOTICE,
  455.         'panic': LOG_EMERG,
  456.         'warn': LOG_WARNING,
  457.         'warning': LOG_WARNING }
  458.     facility_names = {
  459.         'auth': LOG_AUTH,
  460.         'authpriv': LOG_AUTHPRIV,
  461.         'cron': LOG_CRON,
  462.         'daemon': LOG_DAEMON,
  463.         'kern': LOG_KERN,
  464.         'lpr': LOG_LPR,
  465.         'mail': LOG_MAIL,
  466.         'news': LOG_NEWS,
  467.         'security': LOG_AUTH,
  468.         'syslog': LOG_SYSLOG,
  469.         'user': LOG_USER,
  470.         'uucp': LOG_UUCP,
  471.         'local0': LOG_LOCAL0,
  472.         'local1': LOG_LOCAL1,
  473.         'local2': LOG_LOCAL2,
  474.         'local3': LOG_LOCAL3,
  475.         'local4': LOG_LOCAL4,
  476.         'local5': LOG_LOCAL5,
  477.         'local6': LOG_LOCAL6,
  478.         'local7': LOG_LOCAL7 }
  479.     priority_map = {
  480.         'DEBUG': 'debug',
  481.         'INFO': 'info',
  482.         'WARNING': 'warning',
  483.         'ERROR': 'error',
  484.         'CRITICAL': 'critical' }
  485.     
  486.     def __init__(self, address = ('localhost', SYSLOG_UDP_PORT), facility = LOG_USER):
  487.         logging.Handler.__init__(self)
  488.         self.address = address
  489.         self.facility = facility
  490.         if type(address) == types.StringType:
  491.             self.unixsocket = 1
  492.             self._connect_unixsocket(address)
  493.         else:
  494.             self.unixsocket = 0
  495.             self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  496.         self.formatter = None
  497.  
  498.     
  499.     def _connect_unixsocket(self, address):
  500.         self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
  501.         
  502.         try:
  503.             self.socket.connect(address)
  504.         except socket.error:
  505.             self.socket.close()
  506.             self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
  507.             self.socket.connect(address)
  508.  
  509.  
  510.     log_format_string = '<%d>%s\x00'
  511.     
  512.     def encodePriority(self, facility, priority):
  513.         if type(facility) == types.StringType:
  514.             facility = self.facility_names[facility]
  515.         
  516.         if type(priority) == types.StringType:
  517.             priority = self.priority_names[priority]
  518.         
  519.         return facility << 3 | priority
  520.  
  521.     
  522.     def close(self):
  523.         if self.unixsocket:
  524.             self.socket.close()
  525.         
  526.         logging.Handler.close(self)
  527.  
  528.     
  529.     def mapPriority(self, levelName):
  530.         return self.priority_map.get(levelName, 'warning')
  531.  
  532.     
  533.     def emit(self, record):
  534.         msg = self.format(record)
  535.         msg = self.log_format_string % (self.encodePriority(self.facility, self.mapPriority(record.levelname)), msg)
  536.         
  537.         try:
  538.             if self.unixsocket:
  539.                 
  540.                 try:
  541.                     self.socket.send(msg)
  542.                 except socket.error:
  543.                     self._connect_unixsocket(self.address)
  544.                     self.socket.send(msg)
  545.                 except:
  546.                     None<EXCEPTION MATCH>socket.error
  547.                 
  548.  
  549.             None<EXCEPTION MATCH>socket.error
  550.             self.socket.sendto(msg, self.address)
  551.         except (KeyboardInterrupt, SystemExit):
  552.             raise 
  553.         except:
  554.             self.handleError(record)
  555.  
  556.  
  557.  
  558.  
  559. class SMTPHandler(logging.Handler):
  560.     
  561.     def __init__(self, mailhost, fromaddr, toaddrs, subject, credentials = None):
  562.         logging.Handler.__init__(self)
  563.         if type(mailhost) == types.TupleType:
  564.             (self.mailhost, self.mailport) = mailhost
  565.         else:
  566.             self.mailhost = mailhost
  567.             self.mailport = None
  568.         if type(credentials) == types.TupleType:
  569.             (self.username, self.password) = credentials
  570.         else:
  571.             self.username = None
  572.         self.fromaddr = fromaddr
  573.         if type(toaddrs) == types.StringType:
  574.             toaddrs = [
  575.                 toaddrs]
  576.         
  577.         self.toaddrs = toaddrs
  578.         self.subject = subject
  579.  
  580.     
  581.     def getSubject(self, record):
  582.         return self.subject
  583.  
  584.     weekdayname = [
  585.         'Mon',
  586.         'Tue',
  587.         'Wed',
  588.         'Thu',
  589.         'Fri',
  590.         'Sat',
  591.         'Sun']
  592.     monthname = [
  593.         None,
  594.         'Jan',
  595.         'Feb',
  596.         'Mar',
  597.         'Apr',
  598.         'May',
  599.         'Jun',
  600.         'Jul',
  601.         'Aug',
  602.         'Sep',
  603.         'Oct',
  604.         'Nov',
  605.         'Dec']
  606.     
  607.     def date_time(self):
  608.         (year, month, day, hh, mm, ss, wd, y, z) = time.gmtime(time.time())
  609.         s = '%s, %02d %3s %4d %02d:%02d:%02d GMT' % (self.weekdayname[wd], day, self.monthname[month], year, hh, mm, ss)
  610.         return s
  611.  
  612.     
  613.     def emit(self, record):
  614.         
  615.         try:
  616.             import smtplib
  617.             
  618.             try:
  619.                 formatdate = formatdate
  620.                 import email.utils
  621.             except ImportError:
  622.                 formatdate = self.date_time
  623.  
  624.             port = self.mailport
  625.             if not port:
  626.                 port = smtplib.SMTP_PORT
  627.             
  628.             smtp = smtplib.SMTP(self.mailhost, port)
  629.             msg = self.format(record)
  630.             msg = 'From: %s\r\nTo: %s\r\nSubject: %s\r\nDate: %s\r\n\r\n%s' % (self.fromaddr, string.join(self.toaddrs, ','), self.getSubject(record), formatdate(), msg)
  631.             if self.username:
  632.                 smtp.login(self.username, self.password)
  633.             
  634.             smtp.sendmail(self.fromaddr, self.toaddrs, msg)
  635.             smtp.quit()
  636.         except (KeyboardInterrupt, SystemExit):
  637.             raise 
  638.         except:
  639.             self.handleError(record)
  640.  
  641.  
  642.  
  643.  
  644. class NTEventLogHandler(logging.Handler):
  645.     
  646.     def __init__(self, appname, dllname = None, logtype = 'Application'):
  647.         logging.Handler.__init__(self)
  648.         
  649.         try:
  650.             import win32evtlogutil
  651.             import win32evtlog
  652.             self.appname = appname
  653.             self._welu = win32evtlogutil
  654.             if not dllname:
  655.                 dllname = os.path.split(self._welu.__file__)
  656.                 dllname = os.path.split(dllname[0])
  657.                 dllname = os.path.join(dllname[0], 'win32service.pyd')
  658.             
  659.             self.dllname = dllname
  660.             self.logtype = logtype
  661.             self._welu.AddSourceToRegistry(appname, dllname, logtype)
  662.             self.deftype = win32evtlog.EVENTLOG_ERROR_TYPE
  663.             self.typemap = {
  664.                 logging.DEBUG: win32evtlog.EVENTLOG_INFORMATION_TYPE,
  665.                 logging.INFO: win32evtlog.EVENTLOG_INFORMATION_TYPE,
  666.                 logging.WARNING: win32evtlog.EVENTLOG_WARNING_TYPE,
  667.                 logging.ERROR: win32evtlog.EVENTLOG_ERROR_TYPE,
  668.                 logging.CRITICAL: win32evtlog.EVENTLOG_ERROR_TYPE }
  669.         except ImportError:
  670.             print 'The Python Win32 extensions for NT (service, event logging) appear not to be available.'
  671.             self._welu = None
  672.  
  673.  
  674.     
  675.     def getMessageID(self, record):
  676.         return 1
  677.  
  678.     
  679.     def getEventCategory(self, record):
  680.         return 0
  681.  
  682.     
  683.     def getEventType(self, record):
  684.         return self.typemap.get(record.levelno, self.deftype)
  685.  
  686.     
  687.     def emit(self, record):
  688.         if self._welu:
  689.             
  690.             try:
  691.                 id = self.getMessageID(record)
  692.                 cat = self.getEventCategory(record)
  693.                 type = self.getEventType(record)
  694.                 msg = self.format(record)
  695.                 self._welu.ReportEvent(self.appname, id, cat, type, [
  696.                     msg])
  697.             except (KeyboardInterrupt, SystemExit):
  698.                 raise 
  699.             except:
  700.                 None<EXCEPTION MATCH>(KeyboardInterrupt, SystemExit)
  701.                 self.handleError(record)
  702.             
  703.  
  704.         None<EXCEPTION MATCH>(KeyboardInterrupt, SystemExit)
  705.  
  706.     
  707.     def close(self):
  708.         logging.Handler.close(self)
  709.  
  710.  
  711.  
  712. class HTTPHandler(logging.Handler):
  713.     
  714.     def __init__(self, host, url, method = 'GET'):
  715.         logging.Handler.__init__(self)
  716.         method = string.upper(method)
  717.         if method not in ('GET', 'POST'):
  718.             raise ValueError, 'method must be GET or POST'
  719.         method not in ('GET', 'POST')
  720.         self.host = host
  721.         self.url = url
  722.         self.method = method
  723.  
  724.     
  725.     def mapLogRecord(self, record):
  726.         return record.__dict__
  727.  
  728.     
  729.     def emit(self, record):
  730.         
  731.         try:
  732.             import httplib
  733.             import urllib
  734.             host = self.host
  735.             h = httplib.HTTP(host)
  736.             url = self.url
  737.             data = urllib.urlencode(self.mapLogRecord(record))
  738.             if self.method == 'GET':
  739.                 if string.find(url, '?') >= 0:
  740.                     sep = '&'
  741.                 else:
  742.                     sep = '?'
  743.                 url = url + '%c%s' % (sep, data)
  744.             
  745.             h.putrequest(self.method, url)
  746.             i = string.find(host, ':')
  747.             if i >= 0:
  748.                 host = host[:i]
  749.             
  750.             h.putheader('Host', host)
  751.             if self.method == 'POST':
  752.                 h.putheader('Content-type', 'application/x-www-form-urlencoded')
  753.                 h.putheader('Content-length', str(len(data)))
  754.             
  755.             h.endheaders()
  756.             if self.method == 'POST':
  757.                 h.send(data)
  758.             
  759.             h.getreply()
  760.         except (KeyboardInterrupt, SystemExit):
  761.             raise 
  762.         except:
  763.             self.handleError(record)
  764.  
  765.  
  766.  
  767.  
  768. class BufferingHandler(logging.Handler):
  769.     
  770.     def __init__(self, capacity):
  771.         logging.Handler.__init__(self)
  772.         self.capacity = capacity
  773.         self.buffer = []
  774.  
  775.     
  776.     def shouldFlush(self, record):
  777.         return len(self.buffer) >= self.capacity
  778.  
  779.     
  780.     def emit(self, record):
  781.         self.buffer.append(record)
  782.         if self.shouldFlush(record):
  783.             self.flush()
  784.         
  785.  
  786.     
  787.     def flush(self):
  788.         self.buffer = []
  789.  
  790.     
  791.     def close(self):
  792.         self.flush()
  793.         logging.Handler.close(self)
  794.  
  795.  
  796.  
  797. class MemoryHandler(BufferingHandler):
  798.     
  799.     def __init__(self, capacity, flushLevel = logging.ERROR, target = None):
  800.         BufferingHandler.__init__(self, capacity)
  801.         self.flushLevel = flushLevel
  802.         self.target = target
  803.  
  804.     
  805.     def shouldFlush(self, record):
  806.         if not len(self.buffer) >= self.capacity:
  807.             pass
  808.         return record.levelno >= self.flushLevel
  809.  
  810.     
  811.     def setTarget(self, target):
  812.         self.target = target
  813.  
  814.     
  815.     def flush(self):
  816.         if self.target:
  817.             for record in self.buffer:
  818.                 self.target.handle(record)
  819.             
  820.             self.buffer = []
  821.         
  822.  
  823.     
  824.     def close(self):
  825.         self.flush()
  826.         self.target = None
  827.         BufferingHandler.close(self)
  828.  
  829.  
  830.