| Current File : /home/jvzmxxx/wiki/extensions/EventLogging/server/bin/eventlogging-devserver |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
eventlogging-devserver
----------------------
Invoking this command-line tool will spawn a web server that can serve
as a test logging endpoint. Events logged against this server will be
validated verbosely and pretty-printed to the terminal.
To use this, you probably want to set '$wgEventLoggingBaseUri' on your
test wiki to point at the host and port of this web server. The value
'//localhost:8080/event.gif' should work.
Example:
event : {"wiki": "devwiki", "schema": "TrackedPageContentSaveComplete", "revision": 7872558, "event": {"revId": 10, "token": "foobar"}}
url : http://localhost:8080/event.gif?%7B%22wiki%22%3A+%22devwiki%22%2C+%22schema%22%3A+%22TrackedPageContentSaveComplete%22%2C+%22revision%22%3A+7872558%2C+%22event%22%3A+%7B%22revId%22%3A+10%2C+%22token%22%3A+%22foobar%22%7D%7D
usage: eventlogging-devserver [-h] [--host HOST] [--port PORT]
optional arguments:
-h, --help show this help message and exit
--host HOST server host (default: 'localhost')
--port PORT server port (default: 8080)
--append-to PATH file to append to (default: stdout)
--verbose print pretty colors to stderr
:copyright: (c) 2012 by Ori Livneh <ori@wikimedia.org>
:license: GNU General Public Licence 2.0 or later
""" # noqa
# pylint: disable=E0611
from __future__ import print_function, unicode_literals
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
import argparse
import itertools
from wsgiref.simple_server import make_server, WSGIRequestHandler
import eventlogging
import jsonschema
from pygments import formatters, highlight, lexers
from pygments.console import ansiformat
argparser = argparse.ArgumentParser(fromfile_prefix_chars='@')
argparser.add_argument('--host', default='localhost',
help='server host (default: localhost)')
argparser.add_argument('--port', default=8080, type=int,
help='server port (default: 8080)')
argparser.add_argument('--append-to', type=argparse.FileType('a'),
default=sys.stdout,
help='file to append to (optional)')
argparser.add_argument('--verbose', action='store_true',
help='print out events to stderr as they come in')
args = argparser.parse_args()
formatter = formatters.get_formatter_by_name('256', style='rrt')
colorize = ansiformat
json_lexer = lexers.get_lexer_by_name('json')
php_lexer = lexers.get_lexer_by_name('php', startinline=True)
server_software = 'EventLogging/%s' % eventlogging.__version__
seq_ids = itertools.count()
parser = eventlogging.LogParser('%q %{recvFrom}s %{seqId}d %t %h')
log_fmt = ('?%(QUERY_STRING)s %(SERVER_NAME)s '
'%(SEQ_ID)d %(TIME)s %(REMOTE_ADDR)s')
max_qs_size = 900
def heading(caption=None):
if caption is None:
return 74 * '-'
return '-- {:-<95}'.format(colorize('*yellow*', caption) + ' ')
def prepare_response(status, headers):
"""Encode a dictionary of HTTP headers to a list of tuples
containing bytes."""
if eventlogging.compat.PY3:
return status, list(headers.items())
status = status.encode('utf-8')
headers = [(k.encode('utf-8'), v.encode('utf-8')) for k, v in
headers.iteritems()]
return status, headers
class EventLoggingHandler(WSGIRequestHandler):
"""WSGI request handler; annotates environ dict with seq ID and
timestamp in NCSA Common Log Format."""
def get_environ(self):
environ = WSGIRequestHandler.get_environ(self)
environ.update(SEQ_ID=next(seq_ids), TIME=eventlogging.ncsa_utcnow())
return environ
def log_message(self, format, *args): # pylint: disable=W0621
pass # We'll handle logging in the WSGI app.
def validate(log_line):
"""Parse and validate a log line containing an encapsulated event.
Returns a tuple of (event, errors). If no object was decoded,
'event' will be None."""
try:
event = parser.parse(log_line)
except ValueError as err:
return None, [err]
try:
scid = event['schema'], event['revision']
except KeyError as err:
return event, [err]
try:
schema = eventlogging.get_schema(scid, encapsulate=True)
except jsonschema.SchemaError as err:
return event, [err]
validator = jsonschema.Draft3Validator(schema)
return event, list(validator.iter_errors(event))
def validate_size(environ):
"""Check whether the query string respects the maximum size.
Returns a list with a ValueError if the size exceeds the maximum.
Returns an empty list otherwise."""
if 'QUERY_STRING' in environ:
qs_size = len(environ['QUERY_STRING'])
if qs_size > max_qs_size:
return [ValueError(
'Query string size (%d) is greater than max size (%d)' %
(qs_size, max_qs_size))]
return []
def handle_event(environ, start_response):
"""WSGI app; parses, validates and pretty-prints incoming event
requests."""
log_line = log_fmt % environ
event, errors = validate(log_line)
errors.extend(validate_size(environ))
headers = {
'Server': server_software,
'Requested-Event-Valid': str(int(not errors))
}
for i, error in enumerate(errors):
headers['Validation-Error-%d' % (i + 1)] = str(error)
status, headers = prepare_response('204 No Content', headers)
start_response(status, headers)
args.append_to.write(eventlogging.json.dumps(event) + "\n")
if args.verbose:
print(heading('request'))
print(log_line)
print(heading('event'))
pretty_json = eventlogging.json.dumps(event, indent=2, sort_keys=True)
print(highlight(pretty_json, json_lexer, formatter), end='')
print(heading('validation'))
for error in errors:
print(colorize('_red_', 'Error:'), error)
if not errors:
print(colorize('_green_', 'Valid.'))
print(heading())
return []
httpd = make_server(args.host, args.port, handle_event,
handler_class=EventLoggingHandler)
sys.stderr.write('''
___ _
/ (_) \_|_) o
\__ _ _ _ _|_ | __ __, __, _ _ __,
/ | |_|/ / |/ | | _| / \_/ | / | | / |/ | / |
\___/ \/ |__/ | |_/|_/(/\___/\__/ \_/|/\_/|/|_/ | |_/\_/|/
-----------------------------------------/|---/|--------------/|----------
(C) Wikimedia Foundation, 2013 \| \| \|
''' + highlight('''
# Ensure the following values are set in LocalSettings.php:
require_once "$IP/extensions/EventLogging/EventLogging.php";
$wgEventLoggingSchemaApiUri = 'https://meta.wikimedia.org/w/api.php';
# Listening to events.\n''', php_lexer, formatter))
try:
httpd.serve_forever()
except KeyboardInterrupt:
pass