FilterHandler captures the output of another
* Handler and allows the ouput to
* be modified. One or more
* {@link sunlabs.brazil.filter.Filter Filters}
* may be specified to change that output
* before it is returned to the client.
* * This handler provides one of the core services now associated with * the Brazil Server: the ability to dynamically rewrite web content * obtained from an arbitrary source. *
* For instance, the FilterHandler can be used as a proxy for
* a PDA. The wrapped Handler would go to the web to
* obtain the requested pages on behalf of the PDA. Then, a
* Filter would examine all "text/html" pages and rewrite the
* pages so they fit into the PDA's 200 pixel wide screen. Another
* Filter would examine all requested images and dynamically
* dither them to reduce the wireless bandwidth consumed by the PDA.
*
* The following configuration parameters are used to initialize this
* Handler:
typePrefix=text/html causes
* only html documents to be considered for filtering.
* "typePrefix" looks at the content type of the returned document, where
* as "prefix" (and suffix...) look at the URL used to fetch it.
*
* handler
* Handler whose output will be captured
* and then filtered. This is called the "wrapped handler".
*
* filters
* Filter names. The filters are applied in
* the specified order to the output of the wrapped handler. For
* each filter, the following properties are used:
* class: To find the filter implementationprefix, suffix, glob, match, ignoreCase, invert:
* to determine which URL's are processed by this filter.
* These properties are examined at each request, so "upstream"
* filters can effect the inclusion/exclusion of downstream
* filters.
* See {@link sunlabs.brazil.util.MatchString} for more information.
* exitOnError
* initFailure will set
* any of the filters fail to
* initialize. No handler prefix is required.
* * handler=filter * port=8081 * * filter.class=sunlabs.brazil.filter.FilterHandler * filter.handler=proxy * filter.filters=noimg * * proxy.class=sunlabs.brazil.proxy.ProxyHandler * * noimg.class=sunlabs.brazil.filter.TemplateFilter * noimg.template=sunlabs.brazil.template.NoImageTemplate ** These parameters set up a proxy server running on port 8081. As with a * normal proxy, this proxy server forwards all HTTP requests to the target * machine, but it then examines all HTML pages before they are returned to * the client and strips out all
<img> tags. By applying
* different filters, the developer could instead build a server Handler and filtering the output of that
* Handler before sending the output to the client.
*
* At several stages, the Filters are given a chance to
* short-circuit this process:
Filter is given a chance to examine the
* request before it is sent to the Handler
* by invoking its respond() method. The
* Filter may decide to change the request's properties.
* A Filter may even return some content to the client now,
* by (calling request.sendResponse() and
* returning true),
* in which case, neither the Handler nor any further
* Filters are invoked at all.
*
* handler's respond()
* method is called, and is expected to generate content.
* If no content is generated at this step,
* this handler returns false.
*
* Handler has generated the response headers,
* but before it has generated any content, each Filter is
* asked if it would be interested in filtering the content. If no
* Filter is, then the subsequent content from the
* Handler will be sent directly to the client.
*
* Filter is interested
* in filtering the content, then the output of the Handler
* will be sent to each of the interested Filters in order.
* The output of each interested Filter is sent to the
* next one; the output of the final Filter is sent to
* the client.
* Filters
* can decide to reject the content completely, instead of rewriting it.
* true if the request was handled and content
* was generated, false otherwise.
*
* @throws IOException
* if there was an I/O error while sending the response to
* the client.
*/
public boolean
respond(Request request) throws IOException {
if (!isMine.match(request.url)) {
return false;
}
/*
* Let each filter get a crack at the request as a handler.
*/
for (int i = 0; i< filters.length; i++) {
if (filters[i].isMatch(request) &&
filters[i].getFilter().respond(request)) {
return true;
}
}
/*
* Capture output from handler. When the handler is done, run the
* filters.
*/
FilterStream out = new FilterStream(request.out);
request.out = out;
try {
if (handler.respond(request) == false) {
request.log(Server.LOG_DIAGNOSTIC, prefix,
"No output from handler - skipping filters");
return false;
}
if (out.shouldFilter) {
return out.applyFilters(request);
} else {
/*
* handler.respond() has already sent the response.
*/
return true;
}
} finally {
out.restore(request);
}
}
private class FilterStream
extends Request.HttpOutputStream
{
boolean shouldFilter;
Request.HttpOutputStream old;
int count;
Filter[] postFilters;
public
FilterStream(Request.HttpOutputStream old)
{
super(new ByteArrayOutputStream());
this.old = old;
}
/**
* Check if any of the filters want to filter the data, based on
* what's in the HTTP headers. If none of them do, then we don't
* have to filter the data at all, so restore the request's original
* output stream.
*/
public void
sendHeaders(Request request)
throws IOException
{
postFilters = new Filter[filters.length];
boolean check=true; // check shouldFilter()
// do type matching first
if (typePrefix != null) {
String type = request.responseHeaders.get("content-type");
if (type !=null && !type.toLowerCase().startsWith(typePrefix)) {
check=false;
}
}
for (int i = 0; check && i < filters.length; i++) {
FilterInfo f = filters[i];
if (f.isMatch(request) && f.getFilter().shouldFilter(
request, request.responseHeaders)) {
postFilters[count++] = f.getFilter();
}
}
if (count == 0) {
/*
* Based on the HTTP response headers, no filters want to
* process the content, so restore orginal output stream.
*/
request.log(Server.LOG_INFORMATIONAL, prefix,
"no filters activated" +
(check?"":": content type not filterable"));
restore(request);
shouldFilter = false;
old.sendHeaders(request);
} else {
shouldFilter = true;
}
}
public boolean
applyFilters(Request request)
throws IOException
{
request.out.flush();
restore(request);
byte[] content = ((ByteArrayOutputStream) out).toByteArray();
request.log(Server.LOG_INFORMATIONAL, prefix, count +
" filters activated");
for (int i = 0; i < count; i++) {
request.log(Server.LOG_DIAGNOSTIC, prefix,
"Filtering " + request.url + ": " + postFilters[i]);
content = postFilters[i].filter(request,
request.responseHeaders, content);
if (content == null) {
return false;
}
}
request.sendResponse(content, null);
return true;
}
public void
restore(Request request)
{
request.out = old;
}
/**
* Make sure we don't get chunked encoding if we are filtering.
*/
public boolean canChunk() {
return !shouldFilter;
}
}
/**
* Keep track of a filter and its MatchString() information.
* This allows us to do url matching on individual filters.
*/
static class FilterInfo {
Filter filter; // The filter to run
MatchString isMine; // What url's to run it on
public FilterInfo(Filter filter, String name) {
this.filter = filter;
isMine = new MatchString(name + ".");
}
public Filter getFilter() {
return filter;
}
public boolean isMatch(Request request) {
return isMine.match(request.url, request.props);
}
public String toString() {
return isMine.toString();
}
}
}