juplo.de Git - percentcodec/blob - test/src/main/java/de/halbekunst/juplo/test/LoggingHttpServletResponseWrapper.java

   1 package de.halbekunst.juplo.test;
   2
   3 import java.io.IOException;
   4 import java.io.OutputStreamWriter;
   5 import java.io.PrintWriter;
   6 import java.util.Collection;
   7 import java.util.Date;
   8 import java.util.Locale;
   9 import javax.servlet.ServletOutputStream;
  10 import javax.servlet.http.Cookie;
  11 import javax.servlet.http.HttpServletResponse;
  12 import org.slf4j.Logger;
  13 import org.slf4j.LoggerFactory;
  14
  15 /**
  16  * @author kai
  17  */
  18 public class LoggingHttpServletResponseWrapper implements HttpServletResponse {
  19
  20   private final static Logger log = LoggerFactory.getLogger(LoggingHttpServletResponseWrapper.class);
  21
  22   public final static int DEFAULT_BUFFER_SIZE = 1024;
  23
  24   private static long count = 0;
  25
  26   private final Long no;
  27   private final HttpServletResponse response;
  28   private CountingServletOutputStream out;
  29   private ServletOutputStream stream;
  30   private PrintWriter writer;
  31   private int buffer = DEFAULT_BUFFER_SIZE;
  32   private boolean committed = false;
  33
  34
  35   LoggingHttpServletResponseWrapper(String name, HttpServletResponse response) {
  36     no = ++count;
  37     log.debug("New request {}: {}", no, name);
  38     this.response = response;
  39   }
  40
  41
  42   public long close() throws IOException {
  43     if (out == null) {
  44       return -1l;
  45     }
  46     else {
  47       if (writer != null)
  48         writer.close();
  49       else
  50         stream.close();
  51       long result = out.count;
  52       out = null;
  53       buffer = DEFAULT_BUFFER_SIZE;
  54       return result;
  55     }
  56   }
  57
  58   @Override
  59   public void flushBuffer() throws IOException {
  60     log.debug("{} -- flushing buffer", no);
  61     committed = true;
  62     response.flushBuffer();
  63   }
  64
  65   @Override
  66   public int getBufferSize() {
  67     log.trace("{} -- getting buffer size: {}", no, buffer);
  68     return buffer;
  69   }
  70
  71   @Override
  72   public boolean isCommitted() {
  73     Boolean result = committed || response.isCommitted();
  74     log.trace("{} -- commited? {}", no, result);
  75     return result;
  76   }
  77
  78   @Override
  79   public void reset() {
  80     log.debug("{} -- reset!", no);
  81     if (committed)
  82       throw new IllegalStateException("call to reset() after response has been commited!");
  83     if (out != null)
  84       out.count = 0;
  85     response.reset();
  86   }
  87
  88   @Override
  89   public void resetBuffer() {
  90     log.debug("{} -- resetting buffer", no);
  91     if (committed)
  92       throw new IllegalStateException("call to resetBuffer() after response has been commited!");
  93     if (out != null)
  94       out.count = 0;
  95     response.resetBuffer();
  96   }
  97
  98   @Override
  99   public void setBufferSize(int size) {
 100     log.debug("{} -- setting buffer size to {}", no, size);
 101     if (out != null && out.count > 0)
 102       throw new IllegalStateException("call to setBuffer() after content has been written!");
 103     response.setBufferSize(size);
 104     buffer = size;
 105   }
 106
 107   @Override
 108   public ServletOutputStream getOutputStream() throws IOException {
 109     log.debug("{} -- getting output stream", no);
 110
 111     if (writer != null)
 112       throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
 113
 114     if (stream == null) {
 115       log.debug("{} -- creating new servlet output stream", no);
 116       out = new CountingServletOutputStream(response.getOutputStream());
 117       stream = out;
 118     }
 119
 120     return stream;
 121   }
 122
 123   @Override
 124   public PrintWriter getWriter() throws IOException {
 125     log.debug("{} -- getting print writer", no);
 126
 127     if (stream != null)
 128       throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
 129
 130     if (writer == null) {
 131       log.debug("{} -- creating new print writer", no);
 132       out = new CountingServletOutputStream(response.getOutputStream());
 133       OutputStreamWriter streamWriter = new OutputStreamWriter(out, response.getCharacterEncoding());
 134       writer = new PrintWriter(streamWriter);
 135     }
 136
 137     return writer;
 138   }
 139
 140   @Override
 141   public void addCookie(Cookie cookie) {
 142     log.debug("{} -- adding cookie: {}", no, cookie);
 143     response.addCookie(cookie);
 144   }
 145
 146   @Override
 147   public boolean containsHeader(String name) {
 148     Boolean result = response.containsHeader(name);
 149     log.trace("{} -- contains header {}? {}", new Object[] { no, name, result });
 150     return result;
 151   }
 152
 153   @Override
 154   public String encodeURL(String url) {
 155     log.trace("{} -- encoding url {}", no, url);
 156     return response.encodeURL(url);
 157   }
 158
 159   @Override
 160   public String encodeRedirectURL(String url) {
 161     log.trace("{} -- encoding redirect url {}", no, url);
 162     return response.encodeRedirectURL(url);
 163   }
 164
 165   @Override
 166   public String encodeUrl(String url) {
 167     log.trace("{} -- encoding url {}", no, url);
 168     return response.encodeUrl(url);
 169   }
 170
 171   @Override
 172   public String encodeRedirectUrl(String url) {
 173     log.trace("{} -- encoding redirect url {}", no, url);
 174     return response.encodeRedirectUrl(url);
 175   }
 176
 177   @Override
 178   public void sendError(int sc, String msg) throws IOException {
 179     log.debug("{} -- sending error: {}. {}", new Object[] { no, sc, msg });
 180     response.sendError(sc, msg);
 181   }
 182
 183   @Override
 184   public void sendError(int sc) throws IOException {
 185     log.debug("{} -- sending error: {}", no, sc);
 186   }
 187
 188   @Override
 189   public void sendRedirect(String location) throws IOException {
 190     log.debug("{} -- sending redirect: {}", no, location);
 191     response.sendRedirect(location);
 192   }
 193
 194   @Override
 195   public void setDateHeader(String name, long date) {
 196     log.debug("{} -- setting date header {} to {}", new Object[] { no, name, new Date(date) });
 197     response.setDateHeader(name, date);
 198   }
 199
 200   @Override
 201   public void addDateHeader(String name, long date) {
 202     log.debug("{} -- adding date header {}: {}", new Object[] { no, name, new Date(date) });
 203     response.addDateHeader(name, date);
 204   }
 205
 206   @Override
 207   public void setHeader(String name, String value) {
 208     log.debug("{} -- setting header {} to {}", new Object[] { no, name, value });
 209     response.setHeader(name, value);
 210   }
 211
 212   @Override
 213   public void addHeader(String name, String value) {
 214     log.debug("{} -- adding header {}: {}", new Object[] { no, name, value });
 215     response.addHeader(name, value);
 216   }
 217
 218   @Override
 219   public void setIntHeader(String name, int value) {
 220     log.debug("{} -- seting int header {} to {}", new Object[] { no, name, value });
 221     response.setIntHeader(name, value);
 222   }
 223
 224   @Override
 225   public void addIntHeader(String name, int value) {
 226     log.debug("{} -- adding int header {}: {}", new Object[] { no, name, value });
 227     response.addIntHeader(name, value);
 228   }
 229
 230   @Override
 231   public void setStatus(int sc) {
 232     log.debug("{} -- setting status to {}", no, sc);
 233     response.setStatus(sc);
 234   }
 235
 236   @Override
 237   public void setStatus(int sc, String sm) {
 238     log.debug("{} -- setting status to {} (message: {})", new Object[] { no, sc, sm });
 239     response.setStatus(sc, sm);
 240   }
 241
 242   @Override
 243   public String getCharacterEncoding() {
 244     String result = response.getCharacterEncoding();
 245     log.trace("{} -- character encoding: {}", no, result);
 246     return result;
 247   }
 248
 249   @Override
 250   public String getContentType() {
 251     String result = response.getContentType();
 252     log.trace("{} -- content type: {}", no, result);
 253     return result;
 254   }
 255
 256   @Override
 257   public void setCharacterEncoding(String charset) {
 258     log.debug("{} -- setting character encoding to {}", no, charset);
 259     response.setCharacterEncoding(charset);
 260   }
 261
 262   @Override
 263   public void setContentLength(int len) {
 264     log.debug("{} -- setting content length to {}", no, len);
 265     response.setContentLength(len);
 266   }
 267
 268   @Override
 269   public void setContentType(String type) {
 270     log.debug("{} -- setting content type to {}", no, type);
 271     response.setContentType(type);
 272   }
 273
 274   @Override
 275   public void setLocale(Locale loc) {
 276     log.debug("{} -- setting locale to {}", no, loc);
 277     response.setLocale(loc);
 278   }
 279
 280   @Override
 281   public Locale getLocale() {
 282     Locale locale = response.getLocale();
 283     log.trace("{} -- locale: {}", no, locale);
 284     return locale;
 285   }
 286
 287   @Override
 288   public int getStatus() {
 289     Integer status = response.getStatus();
 290     log.trace("{} -- status: {}", no, status);
 291     return status;
 292   }
 293
 294   @Override
 295   public String getHeader(String name) {
 296     String value = response.getHeader(name);
 297     log.trace("{} -- header \"{}\": {}", new Object[] { no, name, value });
 298     return value;
 299   }
 300
 301   @Override
 302   public Collection<String> getHeaders(String name) {
 303     Collection<String> values = response.getHeaders(name);
 304     if (log.isTraceEnabled()) {
 305       StringBuilder builder = new StringBuilder();
 306       builder.append(no);
 307       builder.append(" -- headers \"");
 308       builder.append(name);
 309       builder.append("\":");
 310       for (String value : values) {
 311         builder.append(' ');
 312         builder.append(value);
 313       }
 314       log.trace(builder.toString());
 315     }
 316     return values;
 317   }
 318
 319   @Override
 320   public Collection<String> getHeaderNames() {
 321     Collection<String> values = response.getHeaderNames();
 322     if (log.isTraceEnabled()) {
 323       StringBuilder builder = new StringBuilder();
 324       builder.append(no);
 325       builder.append(" -- header-names:");
 326       for (String value : values) {
 327         builder.append(' ');
 328         builder.append(value);
 329       }
 330       log.trace(builder.toString());
 331     }
 332     return values;
 333   }
 334
 335
 336   class CountingServletOutputStream extends ServletOutputStream {
 337
 338     private ServletOutputStream out;
 339     long count = 0l;
 340
 341
 342     CountingServletOutputStream(ServletOutputStream out) {
 343       this.out = out;
 344     }
 345
 346
 347     @Override
 348     public void write(int i) throws IOException {
 349       count++;
 350       /** Simulate commit, when count is getting bigger then buffer */
 351       if (count == buffer + 1) {
 352         log.info("{} -- simulating commit because buffer overflow! buffer: {}, count: {}", new Object[] { no, buffer, count });
 353         committed = true;
 354       }
 355       log.trace("{} -- writing byte {}: {}", new Object[] { no, count, (char)i });
 356       out.write(i);
 357     }
 358   }
 359 }