| """mailerdaemon - classes to parse mailer-daemon messages""" | |
| import rfc822 | |
| import calendar | |
| import re | |
| import os | |
| import sys | |
| Unparseable = 'mailerdaemon.Unparseable' | |
| class ErrorMessage(rfc822.Message): | |
| def __init__(self, fp): | |
| rfc822.Message.__init__(self, fp) | |
| self.sub = '' | |
| def is_warning(self): | |
| sub = self.getheader('Subject') | |
| if not sub: | |
| return 0 | |
| sub = sub.lower() | |
| if sub.startswith('waiting mail'): return 1 | |
| if 'warning' in sub: return 1 | |
| self.sub = sub | |
| return 0 | |
| def get_errors(self): | |
| for p in EMPARSERS: | |
| self.rewindbody() | |
| try: | |
| return p(self.fp, self.sub) | |
| except Unparseable: | |
| pass | |
| raise Unparseable | |
| # List of re's or tuples of re's. | |
| # If a re, it should contain at least a group (?P<email>...) which | |
| # should refer to the email address. The re can also contain a group | |
| # (?P<reason>...) which should refer to the reason (error message). | |
| # If no reason is present, the emparse_list_reason list is used to | |
| # find a reason. | |
| # If a tuple, the tuple should contain 2 re's. The first re finds a | |
| # location, the second re is repeated one or more times to find | |
| # multiple email addresses. The second re is matched (not searched) | |
| # where the previous match ended. | |
| # The re's are compiled using the re module. | |
| emparse_list_list = [ | |
| 'error: (?P<reason>unresolvable): (?P<email>.+)', | |
| ('----- The following addresses had permanent fatal errors -----\n', | |
| '(?P<email>[^ \n].*)\n( .*\n)?'), | |
| 'remote execution.*\n.*rmail (?P<email>.+)', | |
| ('The following recipients did not receive your message:\n\n', | |
| ' +(?P<email>.*)\n(The following recipients did not receive your message:\n\n)?'), | |
| '------- Failure Reasons --------\n\n(?P<reason>.*)\n(?P<email>.*)', | |
| '^<(?P<email>.*)>:\n(?P<reason>.*)', | |
| '^(?P<reason>User mailbox exceeds allowed size): (?P<email>.+)', | |
| '^5\\d{2} <(?P<email>[^\n>]+)>\\.\\.\\. (?P<reason>.+)', | |
| '^Original-Recipient: rfc822;(?P<email>.*)', | |
| '^did not reach the following recipient\\(s\\):\n\n(?P<email>.*) on .*\n +(?P<reason>.*)', | |
| '^ <(?P<email>[^\n>]+)> \\.\\.\\. (?P<reason>.*)', | |
| '^Report on your message to: (?P<email>.*)\nReason: (?P<reason>.*)', | |
| '^Your message was not delivered to +(?P<email>.*)\n +for the following reason:\n +(?P<reason>.*)', | |
| '^ was not +(?P<email>[^ \n].*?) *\n.*\n.*\n.*\n because:.*\n +(?P<reason>[^ \n].*?) *\n', | |
| ] | |
| # compile the re's in the list and store them in-place. | |
| for i in range(len(emparse_list_list)): | |
| x = emparse_list_list[i] | |
| if type(x) is type(''): | |
| x = re.compile(x, re.MULTILINE) | |
| else: | |
| xl = [] | |
| for x in x: | |
| xl.append(re.compile(x, re.MULTILINE)) | |
| x = tuple(xl) | |
| del xl | |
| emparse_list_list[i] = x | |
| del x | |
| del i | |
| # list of re's used to find reasons (error messages). | |
| # if a string, "<>" is replaced by a copy of the email address. | |
| # The expressions are searched for in order. After the first match, | |
| # no more expressions are searched for. So, order is important. | |
| emparse_list_reason = [ | |
| r'^5\d{2} <>\.\.\. (?P<reason>.*)', | |
| '<>\.\.\. (?P<reason>.*)', | |
| re.compile(r'^<<< 5\d{2} (?P<reason>.*)', re.MULTILINE), | |
| re.compile('===== stderr was =====\nrmail: (?P<reason>.*)'), | |
| re.compile('^Diagnostic-Code: (?P<reason>.*)', re.MULTILINE), | |
| ] | |
| emparse_list_from = re.compile('^From:', re.IGNORECASE|re.MULTILINE) | |
| def emparse_list(fp, sub): | |
| data = fp.read() | |
| res = emparse_list_from.search(data) | |
| if res is None: | |
| from_index = len(data) | |
| else: | |
| from_index = res.start(0) | |
| errors = [] | |
| emails = [] | |
| reason = None | |
| for regexp in emparse_list_list: | |
| if type(regexp) is type(()): | |
| res = regexp[0].search(data, 0, from_index) | |
| if res is not None: | |
| try: | |
| reason = res.group('reason') | |
| except IndexError: | |
| pass | |
| while 1: | |
| res = regexp[1].match(data, res.end(0), from_index) | |
| if res is None: | |
| break | |
| emails.append(res.group('email')) | |
| break | |
| else: | |
| res = regexp.search(data, 0, from_index) | |
| if res is not None: | |
| emails.append(res.group('email')) | |
| try: | |
| reason = res.group('reason') | |
| except IndexError: | |
| pass | |
| break | |
| if not emails: | |
| raise Unparseable | |
| if not reason: | |
| reason = sub | |
| if reason[:15] == 'returned mail: ': | |
| reason = reason[15:] | |
| for regexp in emparse_list_reason: | |
| if type(regexp) is type(''): | |
| for i in range(len(emails)-1,-1,-1): | |
| email = emails[i] | |
| exp = re.compile(re.escape(email).join(regexp.split('<>')), re.MULTILINE) | |
| res = exp.search(data) | |
| if res is not None: | |
| errors.append(' '.join((email.strip()+': '+res.group('reason')).split())) | |
| del emails[i] | |
| continue | |
| res = regexp.search(data) | |
| if res is not None: | |
| reason = res.group('reason') | |
| break | |
| for email in emails: | |
| errors.append(' '.join((email.strip()+': '+reason).split())) | |
| return errors | |
| EMPARSERS = [emparse_list, ] | |
| def sort_numeric(a, b): | |
| a = int(a) | |
| b = int(b) | |
| if a < b: return -1 | |
| elif a > b: return 1 | |
| else: return 0 | |
| def parsedir(dir, modify): | |
| os.chdir(dir) | |
| pat = re.compile('^[0-9]*$') | |
| errordict = {} | |
| errorfirst = {} | |
| errorlast = {} | |
| nok = nwarn = nbad = 0 | |
| # find all numeric file names and sort them | |
| files = filter(lambda fn, pat=pat: pat.match(fn) is not None, os.listdir('.')) | |
| files.sort(sort_numeric) | |
| for fn in files: | |
| # Lets try to parse the file. | |
| fp = open(fn) | |
| m = ErrorMessage(fp) | |
| sender = m.getaddr('From') | |
| print '%s\t%-40s\t'%(fn, sender[1]), | |
| if m.is_warning(): | |
| fp.close() | |
| print 'warning only' | |
| nwarn = nwarn + 1 | |
| if modify: | |
| os.rename(fn, ','+fn) | |
| ## os.unlink(fn) | |
| continue | |
| try: | |
| errors = m.get_errors() | |
| except Unparseable: | |
| print '** Not parseable' | |
| nbad = nbad + 1 | |
| fp.close() | |
| continue | |
| print len(errors), 'errors' | |
| # Remember them | |
| for e in errors: | |
| try: | |
| mm, dd = m.getdate('date')[1:1+2] | |
| date = '%s %02d' % (calendar.month_abbr[mm], dd) | |
| except: | |
| date = '??????' | |
| if not errordict.has_key(e): | |
| errordict[e] = 1 | |
| errorfirst[e] = '%s (%s)' % (fn, date) | |
| else: | |
| errordict[e] = errordict[e] + 1 | |
| errorlast[e] = '%s (%s)' % (fn, date) | |
| fp.close() | |
| nok = nok + 1 | |
| if modify: | |
| os.rename(fn, ','+fn) | |
| ## os.unlink(fn) | |
| print '--------------' | |
| print nok, 'files parsed,',nwarn,'files warning-only,', | |
| print nbad,'files unparseable' | |
| print '--------------' | |
| list = [] | |
| for e in errordict.keys(): | |
| list.append((errordict[e], errorfirst[e], errorlast[e], e)) | |
| list.sort() | |
| for num, first, last, e in list: | |
| print '%d %s - %s\t%s' % (num, first, last, e) | |
| def main(): | |
| modify = 0 | |
| if len(sys.argv) > 1 and sys.argv[1] == '-d': | |
| modify = 1 | |
| del sys.argv[1] | |
| if len(sys.argv) > 1: | |
| for folder in sys.argv[1:]: | |
| parsedir(folder, modify) | |
| else: | |
| parsedir('/ufs/jack/Mail/errorsinbox', modify) | |
| if __name__ == '__main__' or sys.argv[0] == __name__: | |
| main() |