Changeset 2698 for SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRUServer.java

Timestamp:

03/14/13 13:30:06 (11 years ago)

Author:

oschonef

Message:

• buffer output as long as possible (helps to gracefully recover from error conditions with fatal diagnostic)
• make buffer size a configuration parameter
• more debugging information in case of (recoverable) error condition with fatal diagnostics

File:

• SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRUServer.java (modified) (11 diffs)

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRUServer.java

@@ -17 +17 @@
 package eu.clarin.sru.server;
 
+import java.io.FilterOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -65 +66 @@
     static final String RESPONSE_ENCODING = "utf-8";
     private static final String RESPONSE_CONTENT_TYPE = "application/xml";
-    private static final int RESPONSE_BUFFER_SIZE = 64 * 1024;
     private static final Logger logger =
             LoggerFactory.getLogger(SRUServer.class);
@@ -116 +116 @@
             response.setStatus(HttpServletResponse.SC_OK);
             // make sure we can reset the stream later in case of error ...
-            response.setBufferSize(RESPONSE_BUFFER_SIZE);
-
+            response.setBufferSize(config.getResponseBufferSize());
             try {
                 if (req.checkParameters()) {
@@ -135 +134 @@
                     SRUXMLStreamWriter out =
                         createXMLStreamWriter(response.getOutputStream(),
-                                SRURecordPacking.XML, req.getIndentResponse());
+                                SRURecordPacking.XML, false,
+                                req.getIndentResponse());
                     writeFatalError(out, req, req.getDiagnostics());
                 }
@@ -150 +150 @@
         } catch (SRUException e) {
             if (!response.isCommitted()) {
+                if (logger.isInfoEnabled()) {
+                    final String message = e.getDiagnostic().getMessage();
+                    if (message != null) {
+                        logger.info("Sending fatal diagnostic '{}{}' with " +
+                                "message '{}'",
+                                new Object[] {
+                                        SRUConstants.SRU_DIAGNOSTIC_URI_PREFIX,
+                                        e.getDiagnostic().getCode(),
+                                        message
+                                });
+                    } else {
+                        logger.info("Sending fatal diagnostic '{}{}'",
+                                SRUConstants.SRU_DIAGNOSTIC_URI_PREFIX,
+                                e.getDiagnostic().getCode());
+                    }
+                    logger.debug("Fatal diagnostic was caused by " +
+                            "this exception", e);
+                }
                 response.resetBuffer();
                 try {
@@ -160 +178 @@
                     SRUXMLStreamWriter out =
                             createXMLStreamWriter(response.getOutputStream(),
-                                    SRURecordPacking.XML,
+                                    SRURecordPacking.XML, false,
                                     req.getIndentResponse());
                     writeFatalError(out, req, diagnostics);
@@ -168 +186 @@
                 }
             } else {
+                /*
+                 * The servlet already flushed the output buffer, so cannot
+                 * degrade gracefully anymore and, unfortunately, will produce
+                 * ill-formed XML output.
+                 * Increase the response buffer size, if you want to avoid
+                 * this (at the cost of memory).
+                 */
                 logger.error("A fatal error occurred, but the response was "
-                        + "already committed", e);
+                        + "already committed. Unable to recover gracefully.", e);
             }
         }
@@ -188 +213 @@
                     createXMLStreamWriter(response.getOutputStream(),
                                           request.getRecordPacking(),
+                                          true,
                                           request.getIndentResponse());
 
@@ -238 +264 @@
                     createXMLStreamWriter(response.getOutputStream(),
                                           request.getRecordPacking(),
+                                          true,
                                           request.getIndentResponse());
 
@@ -364 +391 @@
                     createXMLStreamWriter(response.getOutputStream(),
                                           request.getRecordPacking(),
+                                          true,
                                           request.getIndentResponse());
 
@@ -1044 +1072 @@
 
     private SRUXMLStreamWriter createXMLStreamWriter(OutputStream out,
-            SRURecordPacking recordPacking, int indent) throws SRUException {
+            SRURecordPacking recordPacking, boolean skipFlush, int indent)
+            throws SRUException {
         try {
-            return new SRUXMLStreamWriter(out, writerFactory, recordPacking,
-                    indent);
+            if (skipFlush) {
+                /*
+                 * Add a FilterOutputStream to delay flush() as long as
+                 * possible. Doing so, enabled us to send an appropriate SRU
+                 * diagnostic in case an error occurs during the serialization
+                 * of the response.
+                 * Of course, if an error occurs when the Servlet response
+                 * buffer already had been flushed, because it was to large,
+                 * we cannot fail gracefully and we will produce ill-formed
+                 * XML output.
+                 */
+                out = new FilterOutputStream(out) {
+                    @Override
+                    public void flush() throws IOException {
+                    }
+
+
+                    @Override
+                    public void close() throws IOException {
+                        super.flush();
+                        super.close();
+                    }
+                };
+            }
+            return new SRUXMLStreamWriter(out, writerFactory,
+                    recordPacking, indent);
         } catch (Exception e) {
             throw new SRUException(SRUConstants.SRU_GENERAL_SYSTEM_ERROR,