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