#! /usr/bin/env python3.3
"""Search an XML formatted Git Fusion log file for matching records."""
import argparse
from datetime import datetime
import functools
import io
import os
import re
import shutil
import signal
import sys
import textwrap
import xml.sax
import xml.sax.handler
import xml.sax.saxutils
from p4gf_l10n import _
import p4gf_log
import p4gf_util
DIVIDER = '=' * 78
HEADER_PRINTED = False
class LogSource(io.RawIOBase):
"""Acts as an XML input source.
Converts the poorly formed input XML "document" into a conformant file.
In particular, adds the XML declaration and the enclosing document tag.
"""
def __init__(self, source):
"""Initialize the LogSource instance."""
self._preamble = io.BytesIO(b'<?xml version="1.0" encoding="iso-8859-1"?>\n<log>\n')
self._source = source
self._appendix = io.BytesIO(b'\n</log>\n')
def readinto(self, b):
"""Read up to len(b) bytes into bytearray b."""
for attr in ['_preamble', '_source', '_appendix']:
src = getattr(self, attr)
if src is not None:
result = src.readinto(b)
# The sax parser reads zero bytes initially to get the type
# of the input stream, so only clear our fields when we are
# really trying to read something.
if result == 0 and len(b) != 0:
setattr(self, attr, None)
else:
return result
return 0
def readable(self):
"""Return a bool indicating whether object was opened for reading."""
# pylint: disable=no-self-use
return True
class LogContentHandler(xml.sax.handler.ContentHandler):
"""Process the content events from the SAX parser."""
def __init__(self, callback):
"""Initialize the LogContentHandler instance."""
xml.sax.handler.ContentHandler.__init__(self)
# Attribute names must match the expected tag names.
self.pid = None
self.dt = None # pylint:disable=invalid-name
self.lvl = None
self.nm = None # pylint:disable=invalid-name
self.msg = None
self.req = None
self._current = None
self._callback = callback
def startElement(self, name, attrs):
"""Signal the start of an element in non-namespace mode."""
if name == 'rec':
self.pid = None
self.dt = None
self.lvl = None
self.nm = None
self.msg = None
self.req = None
elif name != 'log':
self._current = name
def endElement(self, name):
"""Signal the end of an element in non-namespace mode."""
self._current = None
if name == 'rec':
if self.msg is None:
self.msg = ''
self._callback(self)
def characters(self, content):
"""Receive notification of character data."""
if self._current is None:
return
existing = getattr(self, self._current)
if existing is None:
existing = ''
setattr(self, self._current, existing + content)
def __str__(self):
"""Return the string form of this."""
return "[{pid}] |{req}| <{dt}> {{{lvl}}} ({nm}) {msg}".format(
pid=self.pid, dt=self.dt, lvl=self.lvl, nm=self.nm, msg=self.msg, req=self.req)
def search(regex, args, log_file, record):
"""Compare the record with the given search parameters.
:param regex: compiled regular expression for matching (may be None).
:param args: parsed command-line arguments.
:param log_file: name of the log file being scanned.
:param record: parsed log record.
"""
if args.level and record.lvl.lower() != args.level:
return
if args.name and not args.name.search(record.nm.lower()):
return
if args.before or args.after:
# Lazily parse the record date/time string.
dt = datetime.strptime(record.dt, p4gf_log.XML_DATEFMT)
if args.before and args.before < dt:
return
if args.after and args.after > dt:
return
matches = True
if regex:
# Lazily escape the record message.
record.msg = xml.sax.saxutils.unescape(record.msg)
matches = regex.search(record.msg)
if matches:
if args.pretty:
# Wrap long lines in the message text and print on a separate
# line, with indentation to set it apart from the other record
# attributes.
width = shutil.get_terminal_size().columns
lines = []
# Replace the escaped control characters with the real thing to
# improve the readability of the message text.
unescaped_msg = record.msg.replace('\\t', '\t').replace('\\n', '\n')
for line in unescaped_msg.splitlines():
lines.append(textwrap.fill(line, width=width, replace_whitespace=False,
initial_indent=' ', subsequent_indent=' '))
msg = "\n".join(lines)
out = "[{0}] <{1}> {{{2}}} ({3})\n{4}".format(
record.pid, record.dt, record.lvl, record.nm, msg)
else:
out = str(record)
global HEADER_PRINTED
if not args.no_header and not HEADER_PRINTED:
print(log_file)
print(DIVIDER)
HEADER_PRINTED = True
print(out)
def levelup(level):
"""Return the canonical form of the level name."""
lvl = level.lower()
return 'warning' if lvl == 'warn' else lvl
def category_regex(string):
"""Convert the given category name to a compiled regular expression."""
return re.compile(string.lower())
def strptime(string):
"""Parse the string as a date/time in the format found in the XML log."""
try:
return datetime.strptime(string, p4gf_log.XML_DATEFMT)
except ValueError as ve:
raise argparse.ArgumentTypeError(str(ve))
def main():
"""Parse the command-line arguments and perform the requested operation."""
desc = _("""Search an XML formatted Git Fusion log file for matching records.""")
epilog = _("""The --before and --after options take a date/time value with
the following format: YYYY-mm-dd HH:MM:SS (e.g. --before '2015-11-17 10:12:49').
The --name argument can take a regular expression, as supported by the `re`
module in the Python standard library. 'e.g. (p4gf_git_repo_lock|(?<!p4\\.)cmd.*)'""")
parser = p4gf_util.create_arg_parser(desc=desc, epilog=epilog)
parser.add_argument('log', metavar="LOG", nargs='+',
help=_("name of log file(s) to be processed"))
parser.add_argument('-q', '--query',
help=_("regular expression to select log records"))
parser.add_argument('-l', '--level', type=levelup,
help=_("logging level by which to filter (e.g. debug, info, warning)"))
parser.add_argument('-n', '--name', type=category_regex,
help=_("logging category name (e.g. p4gf_auth_server, p4gf_copy_to_p4)"))
parser.add_argument('-B', '--before', type=strptime,
help=_("select log entries before the given date/time"))
parser.add_argument('-A', '--after', type=strptime,
help=_("select log entries after the given date/time"))
parser.add_argument('-i', '--ignore-case', action='store_true',
help=_("compare in a case-insensitive manner"))
parser.add_argument('-p', '--pretty', action='store_true',
help=_("present the log records in a pleasing fashion"))
parser.add_argument('--no-header', action='store_true',
help=_("do not print file name and divider between log files"))
args = parser.parse_args()
flags = re.IGNORECASE if args.ignore_case else 0
regex = re.compile(args.query, flags) if args.query else None
# Suppress the super annoying BrokenPipeError exception when piping our
# output to a utility such as `head`.
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
for log_file in args.log:
if not os.path.exists(log_file):
sys.stderr.write(_('File does not exist: {logfile}\n').format(logfile=log_file))
sys.exit(2)
global HEADER_PRINTED
HEADER_PRINTED = False
callback = functools.partial(search, regex, args, log_file)
with open(log_file, 'rb') as fobj:
xml.sax.parse(LogSource(fobj), LogContentHandler(callback))
if __name__ == "__main__":
main()