1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
__all__ = []
import sys
import time
__all__.append("CloseableIterator")
class CloseableIterator:
"""Concatenating iterator with close attribute."""
def __init__(self, close_function, *iterators):
"""If close_function is not None, it will be the close attribute of
the created iterator object. Further parameters specify iterators
that are to be concatenated."""
if close_function is not None:
self.close = close_function
self.iterators = map(iter, iterators)
def __iter__(self):
"""iterator interface"""
return self
def next(self):
"""iterator interface"""
if not self.iterators:
raise StopIteration
try:
return self.iterators[0].next()
except StopIteration:
self.iterators.pop(0)
return self.next()
__all__.append("CloseableList")
class CloseableList(list):
"""A list with a close attribute."""
def __init__(self, close_function, *args):
"""If close_function is not None, it will be the close attribute of
the created list object. Other parameters are passed to the list
constructor."""
if close_function is not None:
self.close = close_function
list.__init__(self, *args)
def __iter__(self):
return CloseableIterator(getattr(self, "close", None),
list.__iter__(self))
__all__.append("BaseWSGIFilter")
class BaseWSGIFilter:
"""Generic WSGI filter class to be used with WSGIFilterMiddleware.
For each request a filter object gets created.
The environment is then passed through filter_environ.
Possible exceptions are filtered by filter_exc_info.
After that for each (header, value) tuple filter_header is used.
The resulting list is filtered through filter_headers.
Any data is filtered through filter_data.
In order to possibly append data the append_data method is invoked.
When the request has finished handle_close is invoked.
All methods do not modify the passed data by default. Passing the
BaseWSGIFilter class to a WSGIFilterMiddleware will result in not modifying
the request at all.
"""
def __init__(self):
"""This constructor does nothing and can safely be overwritten. It is
only listed here to document that it must be callable without additional
parameters."""
pass
def filter_environ(self, environ):
"""Receives a dict with the environment passed to the wsgi application
and a dict must be returned. The default is to return the same dict."""
return environ
def filter_exc_info(self, exc_info):
"""Receives either None or a tuple passed as third argument to
start_response from the wrapped wsgi application. Either None or such a
tuple must be returned."""
return exc_info
def filter_status(self, status):
"""Receives a status string passed as first argument to start_response
from the wrapped wsgi application. A valid HTTP status string must be
returned."""
return status
def filter_header(self, headername, headervalue):
"""This function is invoked for each (headername, headervalue) tuple in
the second argument to the start_response from the wrapped wsgi
application. Such a value or None for discarding the header must be
returned."""
return (headername, headervalue)
def filter_headers(self, headers):
"""A list of headers passed as the second argument to the start_response
from the wrapped wsgi application is passed to this function and such a
list must also be returned."""
return headers
def filter_data(self, data):
"""For each string that is either written by the write callable or
returned from the wrapped wsgi application this method is invoked. It
must return a string."""
return data
def append_data(self):
"""This function can be used to append data to the response. A list of
strings or some kind of iterable yielding strings has to be returned.
The default is to return an empty list.
"""
return []
def handle_close(self):
"""This method is invoked after the request has finished."""
pass
__all__.append("WSGIFilterMiddleware")
class WSGIFilterMiddleware:
"""This wsgi middleware can be used with specialized BaseWSGIFilters to
modify wsgi requests and/or reponses."""
def __init__(self, app, filterclass):
"""app is a wsgi application.
filterclass is a subclass of BaseWSGIFilter or some class that
implements the interface."""
self.app = app
self.filterclass = filterclass
def __call__(self, environ, start_response):
"""wsgi interface"""
filter = self.filterclass()
environ = filter.filter_environ(environ)
def modified_start_response(status, headers, exc_info=None):
exc_info = filter.filter_exc_info(exc_info)
status = filter.filter_status(status)
headers = (filter.filter_header(h, v) for h, v in headers)
headers = [h for h in headers if h is not None]
headers = filter.filter_headers(headers)
write = start_response(status, headers, exc_info)
def modified_write(data):
write(filter.filter_data(data))
return modified_write
ret = self.app(environ, modified_start_response)
def modified_close():
filter.handle_close()
getattr(ret, "close", lambda:0)()
if isinstance(ret, list):
return CloseableList(modified_close,
[filter.filter_data(data) for data in ret]
+ list(filter.append_data()))
ret = iter(ret)
return CloseableIterator(modified_close,
(filter.filter_data(data) for data in ret),
filter.append_data())
__all__.append("RequestLogWSGIFilter")
class RequestLogWSGIFilter(BaseWSGIFilter):
"""This filter logs all requests in the apache log file format."""
@classmethod
def creator(cls, log):
return lambda:cls(log)
def __init__(self, log=sys.stdout):
self.log = log
self.time = time.strftime("%d/%b/%Y:%T %z")
self.length = 0
def filter_environ(self, environ):
"""BaseWSGIFilter interface"""
self.remote = environ.get("REMOTE_ADDR", "?")
self.reqmethod = environ["REQUEST_METHOD"]
self.path = environ["SCRIPT_NAME"] + environ["PATH_INFO"]
self.proto = environ.get("SERVER_PROTOCOL", None)
self.referrer = environ.get("HTTP_REFERER", "-")
self.useragent = environ.get("HTTP_USER_AGENT", "-")
return environ
def filter_status(self, status):
"""BaseWSGIFilter interface"""
self.status = status.split()[0]
return status
def filter_data(self, data):
"""BaseWSGIFilter interface"""
self.length += len(data)
return data
def handle_close(self):
"""BaseWSGIFilter interface"""
line = '%s - - [%s] "%s' % (self.remote, self.time, self.reqmethod)
line = '%s %s' % (line, self.path)
if self.proto is not None:
line = "%s %s" % (line, self.proto)
line = '%s" %s %d' % (line, self.status, self.length)
if self.referrer is not None:
line = '%s "%s"' % (line, self.referrer)
else:
line += " -"
if self.useragent is not None:
line = '%s "%s"' % (line, self.useragent)
else:
line += " -"
print >> self.log, line
__all__.append("TimerWSGIFilter")
class TimerWSGIFilter(BaseWSGIFilter):
@classmethod
def creator(cls, pattern):
return lambda:cls(pattern)
def __init__(self, pattern="?GenTime"):
self.pattern = pattern
self.start = time.time()
def filter_data(self, data):
"""BaseWSGIFilter interface"""
if data == self.pattern:
return "%8.3g" % (time.time() - self.start)
return data
__all__.append("EncodeWSGIFilter")
class EncodeWSGIFilter(BaseWSGIFilter):
"""Encodes all body data (no headers) with given charset."""
@classmethod
def creator(cls, charset):
return lambda:cls(charset)
def __init__(self, charset="utf-8"):
self.charset = charset
def filter_data(self, data):
"""BaseWSGIFilter interface"""
return data.encode(self.charset)
def filter_header(self, header, value):
if header.lower() != "content-type":
return (header, value)
return (header, "%s; charset=%s" % (value, self.charset))
|