Changeset 2698

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

Location:

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

Files:

• SRUServer.java (modified) (11 diffs)
• SRUServerConfig.java (modified) (7 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,

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

@@ -224 +224 @@
             "eu.clarin.sru.server.allowOverrideIndentResponse";
     /**
+     * Parameter constant for configuring the size of response buffer size. The
+     * servlet will buffer up to this amount of data before sending a response
+     * to the client. The value if the response buffer in bytes.
+     * <p>
+     * Valid values: any positive integer (default 65536)
+     * </p>
+     */
+    public static final String SRU_RESPONSE_BUFFER_SIZE =
+            "eu.clarin.sru.server.responseBufferSize";
+    /**
      * @deprecated use {@link #SRU_TRANSPORT}
      */
@@ -283 +293 @@
     private static final String LEGACY_SRU_ALLOW_OVERRIDE_INDENT_RESPONSE =
             "sru.allowOverrideIndentResponse";
-    private static final int DEFAULT_NUMBER_OF_RECORDS = 100;
-    private static final int DEFAULT_MAXIMUM_RECORDS   = 250;
-    private static final int DEFAULT_NUMBER_OF_TERMS   = 250;
-    private static final int DEFAULT_MAXIMUM_TERMS     = 500;
+    private static final int DEFAULT_NUMBER_OF_RECORDS    = 100;
+    private static final int DEFAULT_MAXIMUM_RECORDS      = 250;
+    private static final int DEFAULT_NUMBER_OF_TERMS      = 250;
+    private static final int DEFAULT_MAXIMUM_TERMS        = 500;
+    private static final int DEFAULT_RESPONSE_BUFFER_SIZE = 64 * 1024;
     private static final String CONFIG_FILE_NAMESPACE_URI =
             "http://www.clarin.eu/sru-server/1.0/";
@@ -626 +637 @@
     private final boolean echoRequests;
     private final int indentResponse;
+    private final int responseBufferSize;
     private final boolean allowOverrideMaximumRecords;
     private final boolean allowOverrideMaximumTerms;
@@ -638 +650 @@
             String database, int numberOfRecords, int maximumRecords,
             int numberOfTerms, int maximumTerms, boolean echoRequests,
-            int indentResponse, boolean allowOverrideMaximumRecords,
+            int indentResponse, int responseBufferSize,
+            boolean allowOverrideMaximumRecords,
             boolean allowOverrideMaximumTerms,
             boolean allowOverrideIndentResponse, DatabaseInfo databaseinfo,
@@ -652 +665 @@
         this.echoRequests                = echoRequests;
         this.indentResponse              = indentResponse;
+        this.responseBufferSize          = responseBufferSize;
         this.allowOverrideMaximumRecords = allowOverrideMaximumRecords;
         this.allowOverrideMaximumTerms   = allowOverrideMaximumTerms;
@@ -751 +765 @@
     public boolean allowOverrideIndentResponse() {
         return allowOverrideIndentResponse;
+    }
+
+
+    public int getResponseBufferSize() {
+        return responseBufferSize;
     }
 
@@ -988 +1007 @@
                     SRU_ALLOW_OVERRIDE_INDENT_RESPONSE, false, false);
 
+            int responseBufferSize = parseNumber(params,
+                    SRU_RESPONSE_BUFFER_SIZE, false,
+                    DEFAULT_RESPONSE_BUFFER_SIZE, 0, -1);
+
             return new SRUServerConfig(transport, host, port, database,
                     numberOfRecords, maximumRecords, numberOfTerms,
                     maximumTerms, echoRequests, indentResponse,
-                    allowOverrideMaximumRecords, allowOverrideMaximumTerms,
-                    allowOverrideIndentResponse, databaseInfo, indexInfo,
-                    schemaInfo);
+                    responseBufferSize, allowOverrideMaximumRecords,
+                    allowOverrideMaximumTerms, allowOverrideIndentResponse,
+                    databaseInfo, indexInfo, schemaInfo);
         } catch (IOException e) {
             throw new SRUConfigException("error reading configuration file", e);