Stream Blob content during encoding instead of materialising it

encodeBlob previously called Blob.getValue(), which loads the entire
content into a single byte array before writing. For large (URL/file-
backed) Blobs this holds the whole payload in memory and fails outright
above ~2 GB (the Java array limit).

Add a streaming path:
- Blob: getAsStream() (lazy InputStream over the URL/file or wrapped
  array) and getLengthLong() (long length, e.g. File.length()), plus the
  File constructor already added.
- StreamHolder: writeStream(InputStream, long) with a materialising
  default (reads fully then writeBytes) so non-overriding encodings
  (string, xml) are unchanged.
- BaseBinaryStreamHolder / FixedBinaryStreamHolder override writeStream
  to copy the content in fixed-size chunks after the length prefix, so
  the payload is never fully held in memory. A guard rejects lengths
  above the 32-bit length field with a clear message.
- Encoder.encodeBlob now streams via writeStream(getAsStream(),
  getLengthLong()).

Add LargeBlobTest, an @ignore'd probe that generates a 3 GB file and
attempts to encode/decode it, documenting the remaining 32-bit length
field limitation. It is disabled so it does not break CI.

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

Author: CesarCoelho

apis/api-area001-v003-mal/src/main/java/org/ccsds/moims/mo/mal/encoding/Encoder.java

@@ -439,7 +439,10 @@ public void encodeBlob(final Blob value) throws MALException {
             } else {
                 checkForNull(value.getValue());
             }
-            outputStream.writeBytes(value.getValue());
+            // Stream the content instead of materialising it into a single byte
+            // array, so that large (URL/file-backed) Blobs are not loaded fully
+            // into memory during encoding.
+            outputStream.writeStream(value.getAsStream(), value.getLengthLong());
         } catch (IOException ex) {
             throw new MALException(ENCODING_EXCEPTION_STR, ex);
         }

apis/api-area001-v003-mal/src/main/java/org/ccsds/moims/mo/mal/encoding/StreamHolder.java

@@ -20,7 +20,9 @@
  */
 package org.ccsds.moims.mo.mal.encoding;
 
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.OutputStream;
 import java.math.BigInteger;
 
@@ -153,6 +155,29 @@ public StreamHolder(OutputStream outputStream) {
      */
     public abstract void writeBytes(final byte[] value) throws IOException;
 
+    /**
+     * Adds a length-prefixed byte block to the output stream, streamed from an
+     * input source without holding the whole payload in memory. The default
+     * implementation reads the input fully and delegates to
+     * {@link #writeBytes(byte[])} for backwards compatibility; sub-classes that
+     * can stream should override this. The input stream is always closed.
+     *
+     * @param input the source of the bytes to encode.
+     * @param length the number of bytes provided by the input.
+     * @throws IOException is there is a problem adding the value to the stream.
+     */
+    public void writeStream(final InputStream input, final long length) throws IOException {
+        try (InputStream in = input) {
+            final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+            final byte[] chunk = new byte[8192];
+            int read;
+            while ((read = in.read(chunk)) != -1) {
+                buffer.write(chunk, 0, read);
+            }
+            writeBytes(buffer.toByteArray());
+        }
+    }
+
     /**
      * Adds a byte to the output stream.
      *

apis/api-area001-v003-mal/src/main/java/org/ccsds/moims/mo/mal/structures/Blob.java

@@ -20,8 +20,10 @@
  */
 package org.ccsds.moims.mo.mal.structures;
 
+import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
+import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
 import java.util.Arrays;
@@ -157,6 +159,58 @@ public int getLength() {
         return length;
     }
 
+    /**
+     * Returns the content of this Blob as a stream, without loading the whole
+     * content into memory. For a URL-based Blob the stream is opened lazily over
+     * the designated resource; for a byte array based Blob the stream reads from
+     * the wrapped array. The returned stream should be closed by the caller.
+     *
+     * @return The Blob content as an input stream.
+     * @throws MALException if the stream could not be opened.
+     */
+    public InputStream getAsStream() throws MALException {
+        if (isURLBased()) {
+            try {
+                return new URL(uvalue).openStream();
+            } catch (IOException ex) {
+                throw new MALException("The Blob URL stream could not be opened: " + uvalue, ex);
+            }
+        }
+
+        return new ByteArrayInputStream((value != null) ? value : new byte[0]);
+    }
+
+    /**
+     * Returns the length of the Blob content as a {@code long}, allowing lengths
+     * larger than {@link Integer#MAX_VALUE}. For a URL-based Blob the length is
+     * that of the designated resource; for a byte array based Blob it is the
+     * length of the wrapped array.
+     *
+     * @return The length of the Blob content in bytes.
+     * @throws MALException if the length could not be determined.
+     */
+    public long getLengthLong() throws MALException {
+        if (isURLBased()) {
+            try {
+                final URL url = new URL(uvalue);
+
+                if ("file".equals(url.getProtocol())) {
+                    return new File(url.toURI()).length();
+                }
+
+                final long len = url.openConnection().getContentLengthLong();
+                if (len < 0) {
+                    throw new MALException("The Blob URL length is unknown: " + uvalue);
+                }
+                return len;
+            } catch (IOException | java.net.URISyntaxException ex) {
+                throw new MALException("The Blob URL length could not be determined: " + uvalue, ex);
+            }
+        }
+
+        return (value != null) ? value.length : 0;
+    }
+
     /**
      * Returns the URL of this Blob.
      *

encodings/encoding-binary/src/main/java/esa/mo/mal/encoder/binary/base/BaseBinaryEncoder.java

@@ -21,6 +21,7 @@
 package esa.mo.mal.encoder.binary.base;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.OutputStream;
 import org.ccsds.moims.mo.mal.MALException;
 import org.ccsds.moims.mo.mal.encoding.Encoder;
@@ -121,6 +122,45 @@ public void writeBytes(final byte[] value) throws IOException {
             }
         }
 
+        @Override
+        public void writeStream(final InputStream input, final long length) throws IOException {
+            if (length > Integer.MAX_VALUE) {
+                throw new IOException("Blob is too large to encode: " + length
+                        + " bytes exceeds the maximum of " + Integer.MAX_VALUE
+                        + " supported by this encoding's 32-bit length field");
+            }
+            writeUnsignedInt((int) length);
+            copyStream(input, length);
+        }
+
+        /**
+         * Copies exactly {@code length} bytes from the input to the output stream
+         * in fixed-size chunks, without holding the whole payload in memory. The
+         * input stream is always closed. The length prefix must already have been
+         * written by the caller.
+         *
+         * @param input the source of the bytes to copy.
+         * @param length the number of bytes to copy.
+         * @throws IOException if there is a problem reading or writing, or if the
+         * input ends before {@code length} bytes have been copied.
+         */
+        protected void copyStream(final InputStream input, final long length) throws IOException {
+            try (InputStream in = input) {
+                final byte[] chunk = new byte[65536];
+                long remaining = length;
+                int read;
+                while (remaining > 0
+                        && (read = in.read(chunk, 0, (int) Math.min(chunk.length, remaining))) != -1) {
+                    write(chunk, 0, read);
+                    remaining -= read;
+                }
+                if (remaining != 0) {
+                    throw new IOException("Blob stream ended early: " + remaining
+                            + " of " + length + " bytes were missing");
+                }
+            }
+        }
+
         @Override
         public void writeString(String value) throws IOException {
             writeBytes(value.getBytes(UTF8_CHARSET));

encodings/encoding-binary/src/main/java/esa/mo/mal/encoder/binary/fixed/FixedBinaryEncoder.java

@@ -22,6 +22,7 @@
 
 import esa.mo.mal.encoder.binary.base.BinaryTimeHandler;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.OutputStream;
 import java.math.BigInteger;
 import org.ccsds.moims.mo.mal.encoding.StreamHolder;
@@ -165,5 +166,21 @@ public void writeBytes(final byte[] value) throws IOException {
                 write(value);
             }
         }
+
+        @Override
+        public void writeStream(final InputStream input, final long length) throws IOException {
+            final long max = shortLengthField ? 0xFFFFL : Integer.MAX_VALUE;
+            if (length > max) {
+                throw new IOException("Blob is too large to encode: " + length
+                        + " bytes exceeds the maximum of " + max
+                        + " supported by this encoding's length field");
+            }
+            if (shortLengthField) {
+                writeUnsignedShort((int) length);
+            } else {
+                writeUnsignedInt((int) length);
+            }
+            copyStream(input, length);
+        }
     }
 }

testbeds/testbed-encoders/src/test/java/esa/mo/mal/encoders/LargeBlobTest.java

@@ -0,0 +1,125 @@
+/* ----------------------------------------------------------------------------
+ * Copyright (C) 2026      European Space Agency
+ *                         European Space Operations Centre
+ *                         Darmstadt
+ *                         Germany
+ * ----------------------------------------------------------------------------
+ * System                : CCSDS MO Transport Framework
+ * ----------------------------------------------------------------------------
+ * Licensed under the European Space Agency Public License, Version 2.0
+ * You may not use this file except in compliance with the License.
+ *
+ * Except as expressly set forth in this License, the Software is provided to
+ * You on an "as is" basis and without warranties of any kind, including without
+ * limitation merchantability, fitness for a particular purpose, absence of
+ * defects or errors, accuracy or non-infringement of intellectual property rights.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ----------------------------------------------------------------------------
+ */
+package esa.mo.mal.encoders;
+
+import esa.mo.mal.encoder.binary.base.BinaryTimeHandler;
+import esa.mo.mal.encoder.binary.fixed.FixedBinaryDecoder;
+import esa.mo.mal.encoder.binary.fixed.FixedBinaryEncoder;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Random;
+import org.ccsds.moims.mo.mal.structures.Blob;
+import org.ccsds.moims.mo.mal.structures.Element;
+import static org.junit.Assume.assumeTrue;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * Probes whether a Blob larger than 2 GB can be encoded and decoded:
+ * generate a 3 GB file, wrap it in a Blob, encode, then decode.
+ */
+public class LargeBlobTest {
+
+    private static final long SIZE = 3L * 1024 * 1024 * 1024; // 3 GB (on purpose > 2 GB)
+
+    @Ignore("A Blob larger than 2 GB cannot yet be encoded (the length prefix is a "
+            + "32-bit field); this probe is expected to fail until that is addressed. "
+            + "Enable it manually to reproduce the limitation.")
+    @Test
+    public void encodeThenDecode3GBBlob() throws Exception {
+        File dir = new File("target/large-blob-test");
+        dir.mkdirs();
+        File srcFile = new File(dir, "blob-3gb.bin");
+        File encodedFile = new File(dir, "encoded.bin");
+
+        // Pre-flight resource checks. This test deliberately uses a 3 GB Blob to
+        // exercise the >2 GB limitation. Without enough heap or disk it would fail
+        // for the wrong reason (a heap OutOfMemoryError, or "No space left on
+        // device") which would mask the actual Blob limitation. In that case,
+        // alert and skip the test rather than report a misleading failure.
+        long maxHeap = Runtime.getRuntime().maxMemory();
+        long freeDisk = dir.getUsableSpace();
+
+        if (maxHeap < SIZE) {
+            System.err.println("ALERT: skipping - not enough heap for a " + SIZE
+                    + " byte Blob. Need -Xmx >= " + SIZE + " bytes, have " + maxHeap
+                    + ". The test would fail with a heap OutOfMemoryError for lack of RAM,"
+                    + " not because of the Blob 2 GB limitation.");
+        }
+        if (freeDisk < SIZE) {
+            System.err.println("ALERT: skipping - not enough free disk to generate a " + SIZE
+                    + " byte file in " + dir.getAbsolutePath() + ". Need " + SIZE
+                    + " bytes, have " + freeDisk + ". The test would fail while writing the"
+                    + " file, not because of the Blob limitation.");
+        }
+        assumeTrue("Not enough heap (-Xmx) for a 3 GB Blob", maxHeap >= SIZE);
+        assumeTrue("Not enough free disk for a 3 GB file", freeDisk >= SIZE);
+
+        try {
+            // 1. Generate a 3 GB file with random content
+            System.out.println("[1] Generating " + SIZE + " byte random file...");
+            byte[] chunk = new byte[8 * 1024 * 1024];
+            Random rnd = new Random(42);
+            long written = 0;
+            try (OutputStream os = new BufferedOutputStream(new FileOutputStream(srcFile))) {
+                while (written < SIZE) {
+                    rnd.nextBytes(chunk);
+                    int toWrite = (int) Math.min(chunk.length, SIZE - written);
+                    os.write(chunk, 0, toWrite);
+                    written += toWrite;
+                }
+            }
+            System.out.println("    File generated: " + srcFile.length() + " bytes");
+
+            // 2. Create a Blob with it (file-based: a byte[] cannot hold 3 GB)
+            Blob blob = new Blob(srcFile);
+            System.out.println("[2] Blob created: " + blob);
+
+            // 3. Encode
+            System.out.println("[3] Encoding...");
+            try (OutputStream fos = new BufferedOutputStream(new FileOutputStream(encodedFile))) {
+                FixedBinaryEncoder encoder = new FixedBinaryEncoder(fos, new BinaryTimeHandler(), false);
+                blob.encode(encoder);
+                encoder.close();
+            }
+            System.out.println("    Encoded: " + encodedFile.length() + " bytes");
+
+            // 4. Decode
+            System.out.println("[4] Decoding...");
+            try (InputStream fis = new BufferedInputStream(new FileInputStream(encodedFile))) {
+                FixedBinaryDecoder decoder = new FixedBinaryDecoder(fis, new BinaryTimeHandler(), false);
+                Element decoded = new Blob().decode(decoder);
+                System.out.println("    Decoded: " + decoded);
+            }
+
+            System.out.println("RESULT: PASS");
+        } finally {
+            srcFile.delete();
+            encodedFile.delete();
+            dir.delete();
+        }
+    }
+}