fix(mediafilter): also skip unparsable docs on the Tika use-temp-file path

The textextractor.use-temp-file branch streamed the source straight into
parser.parse(), so a corrupt PDF there still threw and produced the same
filter-media ERROR flood the in-memory path now avoids. Buffer the bitstream
to a temp input file first (a genuine assetstore read failure surfaces from the
copy and propagates), then parse the local copy and catch IOException/
TikaException as an unparsable-document failure -> WARN + skip. Keeps text
extraction off-heap for large files, matching the in-memory read/parse split.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: jr-rk

dspace-api/src/main/java/org/dspace/app/mediafilter/TikaTextExtractionFilter.java

@@ -14,6 +14,8 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
 
 import org.apache.commons.lang.StringUtils;
 import org.apache.logging.log4j.LogManager;
@@ -69,7 +71,7 @@ public InputStream getDestinationStream(Item currentItem, InputStream source, bo
 
         if (useTemporaryFile) {
             // Extract text out of source file using a temp file, returning results as InputStream
-            return extractUsingTempFile(source, verbose);
+            return extractUsingTempFile(currentItem, source, verbose);
         }
 
         // Not using temporary file. We'll use Tika's default in-memory parsing.
@@ -139,15 +141,25 @@ private void handleOutOfMemory(Item currentItem, OutOfMemoryError oe) {
     /**
      * Extracts the text out of a given source InputStream, using a temporary file. This decreases the amount of memory
      * necessary for text extraction, but can be slower as it requires writing extracted text to a temporary file.
+     * @param currentItem the Item whose bitstream is being processed (used for logging)
      * @param source source InputStream
      * @param verbose verbose mode enabled/disabled
-     * @return InputStream for temporary file containing extracted text
+     * @return InputStream for temporary file containing extracted text, or null if the source could not be parsed
      * @throws IOException
      * @throws SAXException
      * @throws TikaException
      */
-    private InputStream extractUsingTempFile(InputStream source, boolean verbose)
+    private InputStream extractUsingTempFile(Item currentItem, InputStream source, boolean verbose)
         throws IOException, TikaException, SAXException {
+        // Buffer the bitstream to a temporary input file first. A genuine assetstore read failure
+        // (disk/network/S3) surfaces from this copy and propagates; the parse below then reads a local
+        // file, so a parse-time failure can only be an unparsable document. This keeps extraction
+        // off-heap for large files (the reason this path exists) while still distinguishing read
+        // failures from data-quality failures, exactly like the in-memory path.
+        File tempSourceFile = File.createTempFile("dspacetextsource" + source.hashCode(), ".bin");
+        tempSourceFile.deleteOnExit();
+        Files.copy(source, tempSourceFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
+
         File tempExtractedTextFile = File.createTempFile("dspacetextextract" + source.hashCode(), ".txt");
 
         if (verbose) {
@@ -158,7 +170,8 @@ private InputStream extractUsingTempFile(InputStream source, boolean verbose)
         }
 
         // Open temp file for writing
-        try (FileWriter writer = new FileWriter(tempExtractedTextFile, StandardCharsets.UTF_8)) {
+        try (FileWriter writer = new FileWriter(tempExtractedTextFile, StandardCharsets.UTF_8);
+             InputStream bufferedSource = new FileInputStream(tempSourceFile)) {
             // Initialize a custom ContentHandlerDecorator which is a BodyContentHandler.
             // This mimics the behavior of Tika().parseToString(), which only extracts text from the body of the file.
             // This custom Handler writes any extracted text to the temp file.
@@ -204,8 +217,17 @@ public void ignorableWhitespace(char[] ch, int start, int length) throws SAXExce
 
             AutoDetectParser parser = new AutoDetectParser();
             Metadata metadata = new Metadata();
-            // parse our source InputStream using the above custom handler
-            parser.parse(source, handler, metadata);
+            // parse the buffered copy using the above custom handler
+            parser.parse(bufferedSource, handler, metadata);
+        } catch (IOException | TikaException e) {
+            // Parsing the already-buffered copy failed -> malformed/non-standard document (corrupt PDF
+            // header, missing xref, truncated content), not an assetstore read error. Skip instead of
+            // failing the whole filter-media run. See dataquest-dev/dspace-customers#903.
+            log.warn("Unable to extract text from bitstream in Item {}: {}",
+                    currentItem.getHandle(), e.getMessage());
+            return null;
+        } finally {
+            Files.deleteIfExists(tempSourceFile.toPath());
         }
 
         // At this point, all extracted text is written to our temp file. So, return a FileInputStream for that file