From 6144417673e641935da3873cf28e76c7c58d2da3 Mon Sep 17 00:00:00 2001 From: Nicholas DiPiazza Date: Sun, 1 Nov 2020 13:01:46 -0600 Subject: [PATCH 1/6] add a new maxParseTime parameter to the WriteOutContentHandler when > -1, this will stop writing new characters if this number of milliseconds has elapsed since the first characters were written. --- .../src/main/java/org/apache/tika/Tika.java | 4 +- .../tika/parser/RecursiveParserWrapper.java | 37 ++++++-- ...AbstractRecursiveParserWrapperHandler.java | 2 + .../tika/sax/BasicContentHandlerFactory.java | 41 +++++--- .../tika/sax/WriteOutContentHandler.java | 94 ++++++++++++++++++- .../resource/RecursiveMetadataResource.java | 26 ++--- 6 files changed, 162 insertions(+), 42 deletions(-) diff --git a/tika-core/src/main/java/org/apache/tika/Tika.java b/tika-core/src/main/java/org/apache/tika/Tika.java index c0cf281e8b..1c7bf70611 100644 --- a/tika-core/src/main/java/org/apache/tika/Tika.java +++ b/tika-core/src/main/java/org/apache/tika/Tika.java @@ -527,7 +527,7 @@ public String parseToString(InputStream stream, Metadata metadata) parser.parse( stream, new BodyContentHandler(handler), metadata, context); } catch (SAXException e) { - if (!handler.isWriteLimitReached(e)) { + if (!handler.isWriteLimitReached(e) && !handler.isMaxParseTimeReached(e)) { // This should never happen with BodyContentHandler... throw new TikaException("Unexpected SAX processing failure", e); } @@ -568,7 +568,7 @@ public String parseToString(InputStream stream, Metadata metadata, int maxLength parser.parse( stream, new BodyContentHandler(handler), metadata, context); } catch (SAXException e) { - if (!handler.isWriteLimitReached(e)) { + if (!handler.isWriteLimitReached(e) && !handler.isMaxParseTimeReached(e)) { // This should never happen with BodyContentHandler... throw new TikaException("Unexpected SAX processing failure", e); } diff --git a/tika-core/src/main/java/org/apache/tika/parser/RecursiveParserWrapper.java b/tika-core/src/main/java/org/apache/tika/parser/RecursiveParserWrapper.java index e9de9bab37..c175448785 100644 --- a/tika-core/src/main/java/org/apache/tika/parser/RecursiveParserWrapper.java +++ b/tika-core/src/main/java/org/apache/tika/parser/RecursiveParserWrapper.java @@ -233,11 +233,13 @@ public void parse(InputStream stream, ContentHandler recursiveParserWrapperHandl context.set(RecursivelySecureContentHandler.class, secureContentHandler); getWrappedParser().parse(tis, secureContentHandler, metadata, context); } catch (SAXException e) { - boolean wlr = isWriteLimitReached(e); - if (wlr == false) { + if (isWriteLimitReached(e)) { + metadata.set(RecursiveParserWrapperHandler.WRITE_LIMIT_REACHED, "true"); + } else if (isMaxParseTimeReached(e)) { + metadata.set(RecursiveParserWrapperHandler.MAX_PARSE_TIME_REACHED, "true"); + } else { throw e; } - metadata.set(RecursiveParserWrapperHandler.WRITE_LIMIT_REACHED, "true"); } catch (Throwable e) { //try our best to record the problem in the metadata object //then rethrow @@ -323,6 +325,22 @@ private boolean isWriteLimitReached(Throwable t) { } } + /** + * Copied/modified from WriteOutContentHandler. Couldn't make that + * static, and we need to have something that will work + * with exceptions thrown from both BodyContentHandler and WriteOutContentHandler + * @param t The exception to check. + * @return True if this is a MaxParseTimeReachedException exception. + */ + private boolean isMaxParseTimeReached(Throwable t) { + if (t.getMessage() != null && + t.getMessage().indexOf("Your document took more than ") == 0) { + return true; + } else { + return t.getCause() != null && isMaxParseTimeReached(t.getCause()); + } + } + private String getResourceName(Metadata metadata, ParserState state) { String objectName = ""; if (metadata.get(Metadata.RESOURCE_NAME_KEY) != null) { @@ -387,15 +405,14 @@ public void parse(InputStream stream, ContentHandler ignore, try { super.parse(stream, secureContentHandler, metadata, context); } catch (SAXException e) { - boolean wlr = isWriteLimitReached(e); - if (wlr == true) { + if (isWriteLimitReached(e)) { metadata.add(WRITE_LIMIT_REACHED, "true"); + } else if (isMaxParseTimeReached(e)) { + metadata.set(RecursiveParserWrapperHandler.MAX_PARSE_TIME_REACHED, "true"); + } else if (catchEmbeddedExceptions) { + ParserUtils.recordParserFailure(this, e, metadata); } else { - if (catchEmbeddedExceptions) { - ParserUtils.recordParserFailure(this, e, metadata); - } else { - throw e; - } + throw e; } } catch(CorruptedFileException e) { throw e; diff --git a/tika-core/src/main/java/org/apache/tika/sax/AbstractRecursiveParserWrapperHandler.java b/tika-core/src/main/java/org/apache/tika/sax/AbstractRecursiveParserWrapperHandler.java index 8515f09c4c..6a3373dfd1 100644 --- a/tika-core/src/main/java/org/apache/tika/sax/AbstractRecursiveParserWrapperHandler.java +++ b/tika-core/src/main/java/org/apache/tika/sax/AbstractRecursiveParserWrapperHandler.java @@ -43,6 +43,8 @@ public abstract class AbstractRecursiveParserWrapperHandler extends DefaultHandl public final static Property PARSE_TIME_MILLIS = Property.internalText(TikaCoreProperties.TIKA_META_PREFIX + "parse_time_millis"); public final static Property WRITE_LIMIT_REACHED = Property.internalBoolean(TikaCoreProperties.TIKA_META_EXCEPTION_PREFIX + "write_limit_reached"); + public final static Property MAX_PARSE_TIME_REACHED = + Property.internalBoolean(TikaCoreProperties.TIKA_META_EXCEPTION_PREFIX + "max_parse_time_reached"); public final static Property EMBEDDED_RESOURCE_LIMIT_REACHED = Property.internalBoolean(TikaCoreProperties.TIKA_META_EXCEPTION_PREFIX + "embedded_resource_limit_reached"); diff --git a/tika-core/src/main/java/org/apache/tika/sax/BasicContentHandlerFactory.java b/tika-core/src/main/java/org/apache/tika/sax/BasicContentHandlerFactory.java index 899994e053..da8fba3f53 100644 --- a/tika-core/src/main/java/org/apache/tika/sax/BasicContentHandlerFactory.java +++ b/tika-core/src/main/java/org/apache/tika/sax/BasicContentHandlerFactory.java @@ -70,6 +70,7 @@ public enum HANDLER_TYPE { private final HANDLER_TYPE type; private final int writeLimit; + private final long maxParseTime; /** * @@ -79,6 +80,20 @@ public enum HANDLER_TYPE { public BasicContentHandlerFactory(HANDLER_TYPE type, int writeLimit) { this.type = type; this.writeLimit = writeLimit; + this.maxParseTime = -1L; + } + + /** + * + * @param type basic type of handler + * @param writeLimit max number of characters to store; if < 0, the handler will store all characters + * @param maxParseTime if > -1, stop writing characters to store if this many milliseconds has elapsed since + * first characters were written. + */ + public BasicContentHandlerFactory(HANDLER_TYPE type, int writeLimit, long maxParseTime) { + this.type = type; + this.writeLimit = writeLimit; + this.maxParseTime = maxParseTime; } @Override @@ -91,23 +106,21 @@ public ContentHandler getNewContentHandler() { } if (writeLimit > -1) { switch(type) { - case TEXT: - return new WriteOutContentHandler(new ToTextContentHandler(), writeLimit); case HTML: - return new WriteOutContentHandler(new ToHTMLContentHandler(), writeLimit); + return new WriteOutContentHandler(new ToHTMLContentHandler(), writeLimit, maxParseTime); case XML: - return new WriteOutContentHandler(new ToXMLContentHandler(), writeLimit); + return new WriteOutContentHandler(new ToXMLContentHandler(), writeLimit, maxParseTime); default: - return new WriteOutContentHandler(new ToTextContentHandler(), writeLimit); + case TEXT: + return new WriteOutContentHandler(new ToTextContentHandler(), writeLimit, maxParseTime); } } else { switch (type) { - case TEXT: - return new ToTextContentHandler(); case HTML: return new ToHTMLContentHandler(); case XML: return new ToXMLContentHandler(); + case TEXT: default: return new ToTextContentHandler(); @@ -132,26 +145,24 @@ public ContentHandler getNewContentHandler(OutputStream os, Charset charset) { case BODY: return new WriteOutContentHandler( new BodyContentHandler( - new OutputStreamWriter(os, charset)), writeLimit); - case TEXT: - return new WriteOutContentHandler(new ToTextContentHandler(os, charset.name()), writeLimit); + new OutputStreamWriter(os, charset)), writeLimit, maxParseTime); case HTML: - return new WriteOutContentHandler(new ToHTMLContentHandler(os, charset.name()), writeLimit); + return new WriteOutContentHandler(new ToHTMLContentHandler(os, charset.name()), writeLimit, maxParseTime); case XML: - return new WriteOutContentHandler(new ToXMLContentHandler(os, charset.name()), writeLimit); + return new WriteOutContentHandler(new ToXMLContentHandler(os, charset.name()), writeLimit, maxParseTime); + case TEXT: default: - return new WriteOutContentHandler(new ToTextContentHandler(os, charset.name()), writeLimit); + return new WriteOutContentHandler(new ToTextContentHandler(os, charset.name()), writeLimit, maxParseTime); } } else { switch (type) { case BODY: return new BodyContentHandler(new OutputStreamWriter(os, charset)); - case TEXT: - return new ToTextContentHandler(os, charset.name()); case HTML: return new ToHTMLContentHandler(os, charset.name()); case XML: return new ToXMLContentHandler(os, charset.name()); + case TEXT: default: return new ToTextContentHandler(os, charset.name()); diff --git a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java index 90b98ace0c..34a23e6b3b 100644 --- a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java +++ b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java @@ -44,11 +44,22 @@ public class WriteOutContentHandler extends ContentHandlerDecorator { */ private final int writeLimit; + /** + * The maximum amount of time that can be spent parsing in milliseconds. + * Set to -1 for no limit. + */ + private final long maxParseTime; + /** * Number of characters written so far. */ private int writeCount = 0; + /** + * Time the parse started. + */ + private long parseStartedMs = 0; + /** * Creates a content handler that writes content up to the given * write limit to the given content handler. @@ -60,6 +71,36 @@ public class WriteOutContentHandler extends ContentHandlerDecorator { public WriteOutContentHandler(ContentHandler handler, int writeLimit) { super(handler); this.writeLimit = writeLimit; + this.maxParseTime = -1L; + } + + /** + * Creates a content handler that writes content up to the given + * write limit to the given character stream. + * + * @since Apache Tika 1.25 + * @param writer character stream + * @param writeLimit If > -1, stop writing chars to content handler if exceeded this value. + * @param maxParseTime The max time in milliseconds that can be spent parsing this file before we stop parsing. + */ + public WriteOutContentHandler(Writer writer, int writeLimit, long maxParseTime) { + this(new ToTextContentHandler(writer), writeLimit, maxParseTime); + } + + /** + * Creates a content handler that writes content up to the given + * write limit to the given content handler. + * + * @since Apache Tika 1.25 + * @param handler content handler to be decorated + * @param writeLimit write limit + * @param maxParseTime if > -1, stop writing characters to handler if this many milliseconds has elapsed since + * * first characters were written. + */ + public WriteOutContentHandler(ContentHandler handler, int writeLimit, long maxParseTime) { + super(handler); + this.writeLimit = writeLimit; + this.maxParseTime = maxParseTime; } /** @@ -71,7 +112,7 @@ public WriteOutContentHandler(ContentHandler handler, int writeLimit) { * @param writeLimit write limit */ public WriteOutContentHandler(Writer writer, int writeLimit) { - this(new ToTextContentHandler(writer), writeLimit); + this(new ToTextContentHandler(writer), writeLimit, -1L); } /** @@ -81,7 +122,7 @@ public WriteOutContentHandler(Writer writer, int writeLimit) { * @param writer writer */ public WriteOutContentHandler(Writer writer) { - this(writer, -1); + this(writer, -1, -1L); } /** @@ -109,7 +150,7 @@ public WriteOutContentHandler(OutputStream stream) { * or -1 to disable the write limit */ public WriteOutContentHandler(int writeLimit) { - this(new StringWriter(), writeLimit); + this(new StringWriter(), writeLimit, -1L); } /** @@ -132,9 +173,19 @@ public WriteOutContentHandler() { @Override public void characters(char[] ch, int start, int length) throws SAXException { + if (parseStartedMs == 0) { + parseStartedMs = System.currentTimeMillis(); + } if (writeLimit == -1 || writeCount + length <= writeLimit) { super.characters(ch, start, length); writeCount += length; + if (maxParseTime > -1 && System.currentTimeMillis() - parseStartedMs > maxParseTime) { + throw new MaxParseTimeReachedException( + "Your document took more than " + maxParseTime + + " to parse. To receive the full text of the document," + + " increase your max parse limit. (Text up to the limit is" + + " however available).", tag); + } } else { super.characters(ch, start, writeLimit - writeCount); writeCount = writeLimit; @@ -169,7 +220,7 @@ public void ignorableWhitespace(char[] ch, int start, int length) * Checks whether the given exception (or any of it's root causes) was * thrown by this handler as a signal of reaching the write limit. * - * @since Apache Tika 0.7 + * @since Apache Tika 1.25 * @param t throwable * @return true if the write limit was reached, * false otherwise @@ -182,6 +233,23 @@ public boolean isWriteLimitReached(Throwable t) { } } + /** + * Checks whether the given exception (or any of it's root causes) was + * thrown by this handler as a signal of reaching the max parse time. + * + * @since Apache Tika 1.25 + * @param t throwable + * @return true if the write limit was reached, + * false otherwise + */ + public boolean isMaxParseTimeReached(Throwable t) { + if (t instanceof MaxParseTimeReachedException) { + return tag.equals(((MaxParseTimeReachedException) t).tag); + } else { + return t.getCause() != null && isMaxParseTimeReached(t.getCause()); + } + } + /** * The exception used as a signal when the write limit has been reached. */ @@ -200,4 +268,22 @@ public WriteLimitReachedException(String message, Serializable tag) { } + /** + * The exception used as a signal when the write limit has been reached. + */ + private static class MaxParseTimeReachedException extends SAXException { + + /** Serial version UID */ + private static final long serialVersionUID = -5860681246457428931L; + + /** Serializable tag of the handler that caused this exception */ + private final Serializable tag; + + public MaxParseTimeReachedException(String message, Serializable tag) { + super(message); + this.tag = tag; + } + + } + } diff --git a/tika-server/src/main/java/org/apache/tika/server/resource/RecursiveMetadataResource.java b/tika-server/src/main/java/org/apache/tika/server/resource/RecursiveMetadataResource.java index 71e71809d2..7261206202 100644 --- a/tika-server/src/main/java/org/apache/tika/server/resource/RecursiveMetadataResource.java +++ b/tika-server/src/main/java/org/apache/tika/server/resource/RecursiveMetadataResource.java @@ -31,7 +31,6 @@ import java.io.InputStream; import org.apache.cxf.jaxrs.ext.multipart.Attachment; -import org.apache.tika.language.detect.LanguageHandler; import org.apache.tika.metadata.Metadata; import org.apache.tika.parser.ParseContext; import org.apache.tika.parser.Parser; @@ -139,20 +138,25 @@ private MetadataList parseMetadata(InputStream is, Metadata metadata, TikaResource.fillParseContext(context, httpHeaders, null); TikaResource.logRequest(LOG, info, metadata); - int writeLimit = -1; - if (httpHeaders.containsKey("writeLimit")) { - writeLimit = Integer.parseInt(httpHeaders.getFirst("writeLimit")); - } + int writeLimit = -1; + if (httpHeaders.containsKey("writeLimit")) { + writeLimit = Integer.parseInt(httpHeaders.getFirst("writeLimit")); + } - int maxEmbeddedResources = -1; - if (httpHeaders.containsKey("maxEmbeddedResources")) { - maxEmbeddedResources = Integer.parseInt(httpHeaders.getFirst("maxEmbeddedResources")); - } + int maxEmbeddedResources = -1; + if (httpHeaders.containsKey("maxEmbeddedResources")) { + maxEmbeddedResources = Integer.parseInt(httpHeaders.getFirst("maxEmbeddedResources")); + } + + long maxParseTime = -1L; + if (httpHeaders.containsKey("maxParseTime")) { + maxParseTime = Long.parseLong(httpHeaders.getFirst("maxParseTime")); + } - BasicContentHandlerFactory.HANDLER_TYPE type = + BasicContentHandlerFactory.HANDLER_TYPE type = BasicContentHandlerFactory.parseHandlerType(handlerTypeName, DEFAULT_HANDLER_TYPE); RecursiveParserWrapperHandler handler = new RecursiveParserWrapperHandler( - new BasicContentHandlerFactory(type, writeLimit), maxEmbeddedResources, + new BasicContentHandlerFactory(type, writeLimit, maxParseTime), maxEmbeddedResources, TikaResource.getConfig().getMetadataFilter()); try { TikaResource.parse(wrapper, LOG, info.getPath(), is, handler, metadata, context); From 3c8d82352dd4e39b24585398e80037d63a0e9f4a Mon Sep 17 00:00:00 2001 From: Nicholas DiPiazza Date: Sun, 1 Nov 2020 13:18:07 -0600 Subject: [PATCH 2/6] fix the if statement when to apply the filter. add a unit test. --- .../tika/sax/BasicContentHandlerFactory.java | 4 +-- .../server/RecursiveMetadataResourceTest.java | 33 +++++++++++++++++++ 2 files changed, 35 insertions(+), 2 deletions(-) diff --git a/tika-core/src/main/java/org/apache/tika/sax/BasicContentHandlerFactory.java b/tika-core/src/main/java/org/apache/tika/sax/BasicContentHandlerFactory.java index da8fba3f53..361c23da52 100644 --- a/tika-core/src/main/java/org/apache/tika/sax/BasicContentHandlerFactory.java +++ b/tika-core/src/main/java/org/apache/tika/sax/BasicContentHandlerFactory.java @@ -104,7 +104,7 @@ public ContentHandler getNewContentHandler() { } else if (type == HANDLER_TYPE.IGNORE) { return new DefaultHandler(); } - if (writeLimit > -1) { + if (writeLimit > -1 || maxParseTime > -1L) { switch(type) { case HTML: return new WriteOutContentHandler(new ToHTMLContentHandler(), writeLimit, maxParseTime); @@ -140,7 +140,7 @@ public ContentHandler getNewContentHandler(OutputStream os, Charset charset) { return new DefaultHandler(); } try { - if (writeLimit > -1) { + if (writeLimit > -1 || maxParseTime > -1L) { switch (type) { case BODY: return new WriteOutContentHandler( diff --git a/tika-server/src/test/java/org/apache/tika/server/RecursiveMetadataResourceTest.java b/tika-server/src/test/java/org/apache/tika/server/RecursiveMetadataResourceTest.java index 544a6021ea..d58d260f21 100644 --- a/tika-server/src/test/java/org/apache/tika/server/RecursiveMetadataResourceTest.java +++ b/tika-server/src/test/java/org/apache/tika/server/RecursiveMetadataResourceTest.java @@ -376,4 +376,37 @@ public void testWriteLimit() throws Exception { metadataList.get(6).get(AbstractRecursiveParserWrapperHandler.TIKA_CONTENT)); } + + @Test + public void testMaxParseTimeLimit() throws Exception { + long maxParseTime = 1L; + Response response = WebClient + .create(endPoint + META_PATH) + .accept("application/json") + .header("maxParseTime", Long.toString(maxParseTime)) + .put(ClassLoader + .getSystemResourceAsStream(TEST_RECURSIVE_DOC)); + + assertEquals(200, response.getStatus()); + // Check results + Reader reader = new InputStreamReader((InputStream) response.getEntity(), UTF_8); + List metadataList = JsonMetadataList.fromJson(reader); + assertEquals("true", metadataList.get(0).get(AbstractRecursiveParserWrapperHandler.MAX_PARSE_TIME_REACHED)); + + // now test with -1L + maxParseTime = -1L; + response = WebClient + .create(endPoint + META_PATH) + .accept("application/json") + .header("maxParseTime", Long.toString(maxParseTime)) + .put(ClassLoader + .getSystemResourceAsStream(TEST_RECURSIVE_DOC)); + + assertEquals(200, response.getStatus()); + // Check results + reader = new InputStreamReader((InputStream) response.getEntity(), UTF_8); + metadataList = JsonMetadataList.fromJson(reader); + assertNull(metadataList.get(0).get(AbstractRecursiveParserWrapperHandler.MAX_PARSE_TIME_REACHED)); + + } } From 113502791afa4e788ef8d47da6010c67bfdaf587 Mon Sep 17 00:00:00 2001 From: Nicholas DiPiazza Date: Sun, 1 Nov 2020 13:32:42 -0600 Subject: [PATCH 3/6] fix javadoc formatting issue --- .../main/java/org/apache/tika/sax/WriteOutContentHandler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java index 34a23e6b3b..c16239d4a7 100644 --- a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java +++ b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java @@ -95,7 +95,7 @@ public WriteOutContentHandler(Writer writer, int writeLimit, long maxParseTime) * @param handler content handler to be decorated * @param writeLimit write limit * @param maxParseTime if > -1, stop writing characters to handler if this many milliseconds has elapsed since - * * first characters were written. + * first characters were written. */ public WriteOutContentHandler(ContentHandler handler, int writeLimit, long maxParseTime) { super(handler); From 7355fec361345a59bd27ec2b8761687be907b4bf Mon Sep 17 00:00:00 2001 From: Nicholas DiPiazza Date: Sun, 1 Nov 2020 13:35:33 -0600 Subject: [PATCH 4/6] add time unit in message. --- .../main/java/org/apache/tika/sax/WriteOutContentHandler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java index c16239d4a7..49c8336852 100644 --- a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java +++ b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java @@ -182,7 +182,7 @@ public void characters(char[] ch, int start, int length) if (maxParseTime > -1 && System.currentTimeMillis() - parseStartedMs > maxParseTime) { throw new MaxParseTimeReachedException( "Your document took more than " + maxParseTime - + " to parse. To receive the full text of the document," + + " ms to parse. To receive the full text of the document," + " increase your max parse limit. (Text up to the limit is" + " however available).", tag); } From 300ae37e231eacfbf17bbd069cf91704621cf491 Mon Sep 17 00:00:00 2001 From: Nicholas DiPiazza Date: Sun, 1 Nov 2020 13:36:42 -0600 Subject: [PATCH 5/6] fix @Since accidentally changed --- .../main/java/org/apache/tika/sax/WriteOutContentHandler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java index 49c8336852..8d5a1b31e2 100644 --- a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java +++ b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java @@ -220,7 +220,7 @@ public void ignorableWhitespace(char[] ch, int start, int length) * Checks whether the given exception (or any of it's root causes) was * thrown by this handler as a signal of reaching the write limit. * - * @since Apache Tika 1.25 + * @since Apache Tika 0.7 * @param t throwable * @return true if the write limit was reached, * false otherwise From 5650ba864b47ff8326c0eb468b8e211b6a466910 Mon Sep 17 00:00:00 2001 From: Nicholas DiPiazza Date: Sun, 1 Nov 2020 13:37:31 -0600 Subject: [PATCH 6/6] fix javaadoc --- .../main/java/org/apache/tika/sax/WriteOutContentHandler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java index 8d5a1b31e2..099dee5e7c 100644 --- a/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java +++ b/tika-core/src/main/java/org/apache/tika/sax/WriteOutContentHandler.java @@ -269,7 +269,7 @@ public WriteLimitReachedException(String message, Serializable tag) { } /** - * The exception used as a signal when the write limit has been reached. + * The exception used as a signal when the max parse time has been reached. */ private static class MaxParseTimeReachedException extends SAXException {