Fix streamWriteContext, parser ThreadLocal byte-array leak, SerializedString stubs, and Version

- MessagePackGenerator: implement streamWriteContext() using SimpleStreamWriteContext;
  wire writeStartArray/Object, endCurrentContainer, writeName, _verifyValueWrite,
  currentValue, and assignCurrentValue to track write context correctly
- MessagePackParser: on close, null out the byte-array source in the ThreadLocal to
  release large payload references; InputStream sources are preserved to keep the
  sequential-read-from-same-stream behavior working
- MessagePackSerializedString: implement all stub append/write/put methods
- Add PackageVersion (0.9.12) and use it in generator, parser, and factory
- Note: messageBufferOutputHolder ThreadLocal not fixed — clearing it causes 23%
  serialization regression by defeating the OutputStreamBufferOutput reuse cache

Author: komamitsu

msgpack-jackson3/src/main/java/org/msgpack/jackson/dataformat/MessagePackFactory.java

@@ -188,7 +188,7 @@ public TokenStreamFactory snapshot()
     @Override
     public Version version()
     {
-        return Version.unknownVersion();
+        return PackageVersion.VERSION;
     }
 
     @VisibleForTesting

msgpack-jackson3/src/main/java/org/msgpack/jackson/dataformat/MessagePackGenerator.java

@@ -18,11 +18,13 @@
 import tools.jackson.core.Base64Variant;
 import tools.jackson.core.JacksonException;
 import tools.jackson.core.util.JacksonFeatureSet;
+import tools.jackson.core.util.SimpleStreamWriteContext;
 import tools.jackson.core.JsonGenerator;
 import tools.jackson.core.ObjectWriteContext;
 import tools.jackson.core.SerializableString;
 import tools.jackson.core.StreamWriteCapability;
 import tools.jackson.core.StreamWriteFeature;
+import tools.jackson.core.TokenStreamContext;
 import tools.jackson.core.base.GeneratorBase;
 import tools.jackson.core.io.IOContext;
 import tools.jackson.core.io.SerializedString;
@@ -61,6 +63,7 @@ public class MessagePackGenerator
     private int currentState = IN_ROOT;
     private final List<Node> nodes;
     private boolean isElementsClosed = false;
+    private SimpleStreamWriteContext writeContext;
 
     private static final class AsciiCharString
     {
@@ -201,6 +204,7 @@ private MessagePackGenerator(
         this.packerConfig = packerConfig;
         this.nodes = new ArrayList<>();
         this.supportIntegerKeys = supportIntegerKeys;
+        this.writeContext = SimpleStreamWriteContext.createRootContext(null);
     }
 
     public MessagePackGenerator(
@@ -219,6 +223,7 @@ public MessagePackGenerator(
         this.packerConfig = packerConfig;
         this.nodes = new ArrayList<>();
         this.supportIntegerKeys = supportIntegerKeys;
+        this.writeContext = SimpleStreamWriteContext.createRootContext(null);
     }
 
     private MessageBufferOutput getMessageBufferOutputForOutputStream(
@@ -270,6 +275,7 @@ public JsonGenerator writeStartArray(Object currentValue) throws JacksonExceptio
     @Override
     public JsonGenerator writeStartArray(Object currentValue, int size) throws JacksonException
     {
+        writeContext = writeContext.createChildArrayContext(currentValue);
         if (currentState == IN_OBJECT) {
             Node node = nodes.get(nodes.size() - 1);
             assert node instanceof NodeEntryInObject;
@@ -309,6 +315,7 @@ public JsonGenerator writeStartObject(Object currentValue) throws JacksonExcepti
     @Override
     public JsonGenerator writeStartObject(Object forValue, int size) throws JacksonException
     {
+        writeContext = writeContext.createChildObjectContext(forValue);
         if (currentState == IN_OBJECT) {
             Node node = nodes.get(nodes.size() - 1);
             assert node instanceof NodeEntryInObject;
@@ -335,6 +342,7 @@ public JsonGenerator writeEndObject() throws JacksonException
 
     private void endCurrentContainer()
     {
+        writeContext = writeContext.clearAndGetParent();
         Node parent = nodes.get(currentParentElementIndex);
         if (currentParentElementIndex == 0) {
             isElementsClosed = true;
@@ -553,6 +561,7 @@ public JacksonFeatureSet<StreamWriteCapability> streamWriteCapabilities()
     @Override
     public JsonGenerator writeName(String name) throws JacksonException
     {
+        writeContext.writeName(name);
         addKeyNode(name);
         return this;
     }
@@ -953,13 +962,13 @@ private void flushMessagePacker()
     @Override
     public tools.jackson.core.Version version()
     {
-        return tools.jackson.core.Version.unknownVersion();
+        return PackageVersion.VERSION;
     }
 
     @Override
-    public tools.jackson.core.TokenStreamContext streamWriteContext()
+    public TokenStreamContext streamWriteContext()
     {
-        return null;
+        return writeContext;
     }
 
     @Override
@@ -977,12 +986,13 @@ public int streamWriteOutputBuffered()
     @Override
     public Object currentValue()
     {
-        return null;
+        return writeContext.currentValue();
     }
 
     @Override
     public void assignCurrentValue(Object v)
     {
+        writeContext.assignCurrentValue(v);
     }
 
     @Override
@@ -999,6 +1009,7 @@ protected void _releaseBuffers()
     @Override
     protected void _verifyValueWrite(String typeMsg) throws JacksonException
     {
+        writeContext.writeValue();
     }
 
     private MessagePacker getMessagePacker()

msgpack-jackson3/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java

@@ -135,7 +135,7 @@ public void setExtensionTypeCustomDeserializers(ExtensionTypeCustomDeserializers
     @Override
     public Version version()
     {
-        return Version.unknownVersion();
+        return PackageVersion.VERSION;
     }
 
     private String unpackString(MessageUnpacker messageUnpacker) throws IOException
@@ -577,6 +577,10 @@ public void close()
         }
         finally {
             isClosed = true;
+            Tuple<Object, MessageUnpacker> tuple = messageUnpackerHolder.get();
+            if (tuple != null && tuple.first() instanceof byte[]) {
+                messageUnpackerHolder.set(new Tuple<>(null, tuple.second()));
+            }
         }
     }
 

msgpack-jackson3/src/main/java/org/msgpack/jackson/dataformat/MessagePackSerializedString.java

@@ -17,6 +17,7 @@
 
 import tools.jackson.core.SerializableString;
 
+import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
@@ -66,49 +67,75 @@ public byte[] asQuotedUTF8()
     @Override
     public int appendQuotedUTF8(byte[] bytes, int i)
     {
-        return 0;
+        byte[] utf8 = asQuotedUTF8();
+        System.arraycopy(utf8, 0, bytes, i, utf8.length);
+        return utf8.length;
     }
 
     @Override
     public int appendQuoted(char[] chars, int i)
     {
-        return 0;
+        char[] q = asQuotedChars();
+        System.arraycopy(q, 0, chars, i, q.length);
+        return q.length;
     }
 
     @Override
     public int appendUnquotedUTF8(byte[] bytes, int i)
     {
-        return 0;
+        byte[] utf8 = asUnquotedUTF8();
+        System.arraycopy(utf8, 0, bytes, i, utf8.length);
+        return utf8.length;
     }
 
     @Override
     public int appendUnquoted(char[] chars, int i)
     {
-        return 0;
+        String v = getValue();
+        v.getChars(0, v.length(), chars, i);
+        return v.length();
     }
 
     @Override
     public int writeQuotedUTF8(OutputStream outputStream)
     {
-        return 0;
+        try {
+            byte[] utf8 = asQuotedUTF8();
+            outputStream.write(utf8);
+            return utf8.length;
+        }
+        catch (IOException e) {
+            return -1;
+        }
     }
 
     @Override
     public int writeUnquotedUTF8(OutputStream outputStream)
     {
-        return 0;
+        try {
+            byte[] utf8 = asUnquotedUTF8();
+            outputStream.write(utf8);
+            return utf8.length;
+        }
+        catch (IOException e) {
+            return -1;
+        }
     }
 
     @Override
     public int putQuotedUTF8(ByteBuffer byteBuffer)
     {
-        return 0;
+        byte[] utf8 = asQuotedUTF8();
+        byteBuffer.put(utf8);
+        return utf8.length;
     }
 
     @Override
     public int putUnquotedUTF8(ByteBuffer byteBuffer)
     {
-        return 0;
+        byte[] utf8 = asUnquotedUTF8();
+        byteBuffer.put(utf8);
+        return utf8.length;
     }
 
     public Object getRawValue()

msgpack-jackson3/src/main/java/org/msgpack/jackson/dataformat/PackageVersion.java

@@ -0,0 +1,30 @@
+// MessagePack for Java
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.jackson.dataformat;
+
+import tools.jackson.core.Version;
+import tools.jackson.core.Versioned;
+
+public class PackageVersion
+        implements Versioned
+{
+    public static final Version VERSION = new Version(0, 9, 12, null, "org.msgpack", "msgpack-jackson3");
+
+    @Override
+    public Version version()
+    {
+        return VERSION;
+    }
+}

msgpack-jackson3/src/test/java/org/msgpack/jackson/dataformat/MessagePackGeneratorTest.java

@@ -21,6 +21,7 @@
 import tools.jackson.core.JacksonException;
 import tools.jackson.core.ObjectWriteContext;
 import tools.jackson.core.StreamWriteFeature;
+import tools.jackson.core.TokenStreamContext;
 import tools.jackson.databind.ObjectMapper;
 import tools.jackson.databind.SerializationContext;
 import tools.jackson.databind.ValueSerializer;
@@ -1127,4 +1128,83 @@ public void testWriteBinaryByteBufferWithOffset()
         byte[] result = unpacker.readPayload(unpacker.unpackBinaryHeader());
         assertArrayEquals(new byte[] {0x01, 0x02, 0x03}, result);
     }
+
+    @Test
+    public void testStreamWriteContext()
+            throws IOException
+    {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        JsonGenerator generator = factory.createGenerator(ObjectWriteContext.empty(), baos);
+
+        TokenStreamContext ctx = generator.streamWriteContext();
+        assertNotEquals(null, ctx);
+        assertTrue(ctx.inRoot());
+
+        generator.writeStartArray();
+        ctx = generator.streamWriteContext();
+        assertTrue(ctx.inArray());
+
+        generator.writeStartObject();
+        ctx = generator.streamWriteContext();
+        assertTrue(ctx.inObject());
+
+        generator.writeName("k");
+        assertEquals("k", ctx.currentName());
+
+        generator.writeNumber(1);
+        generator.writeEndObject();
+        ctx = generator.streamWriteContext();
+        assertTrue(ctx.inArray());
+
+        generator.writeEndArray();
+        ctx = generator.streamWriteContext();
+        assertTrue(ctx.inRoot());
+
+        generator.close();
+    }
+
+    @Test
+    public void testCurrentValue()
+            throws IOException
+    {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        JsonGenerator generator = factory.createGenerator(ObjectWriteContext.empty(), baos);
+
+        Object pojo = new Object();
+        generator.writeStartObject(pojo);
+        assertEquals(pojo, generator.currentValue());
+        generator.writeName("k");
+        generator.writeNumber(1);
+        generator.writeEndObject();
+        generator.close();
+    }
+
+    @Test
+    public void testVersion()
+    {
+        assertNotEquals(null, factory.version());
+        assertEquals("org.msgpack", factory.version().getGroupId());
+        assertEquals("msgpack-jackson3", factory.version().getArtifactId());
+    }
+
+    @Test
+    public void testSerializedStringMethods()
+    {
+        MessagePackSerializedString s = new MessagePackSerializedString("hello");
+
+        byte[] utf8Target = new byte[10];
+        int written = s.appendUnquotedUTF8(utf8Target, 2);
+        assertEquals(5, written);
+        assertArrayEquals(new byte[] {'h', 'e', 'l', 'l', 'o'}, Arrays.copyOfRange(utf8Target, 2, 7));
+
+        char[] charTarget = new char[10];
+        written = s.appendUnquoted(charTarget, 3);
+        assertEquals(5, written);
+        assertEquals("hello", new String(charTarget, 3, 5));
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        written = s.writeUnquotedUTF8(baos);
+        assertEquals(5, written);
+        assertArrayEquals("hello".getBytes(java.nio.charset.StandardCharsets.UTF_8), baos.toByteArray());
+    }
 }

msgpack-jackson3/src/test/java/org/msgpack/jackson/dataformat/MessagePackParserTest.java

@@ -1089,4 +1089,23 @@ public void handleMissingValueInMap()
             objectMapper.readValue(out.toByteArray(), new TypeReference<Map<String, Integer>>() {});
         });
     }
+
+    @Test
+    public void testByteArrayThreadLocalClearedAfterClose()
+            throws IOException
+    {
+        ObjectMapper objectMapper = new MessagePackMapper(new MessagePackFactory());
+
+        byte[] bytes = objectMapper.writeValueAsBytes(Arrays.asList(1, 2, 3));
+
+        // Parse once; this caches the byte array in the ThreadLocal
+        objectMapper.readValue(bytes, new TypeReference<List<Integer>>() {});
+
+        // Parse again with the same byte array instance and AUTO_CLOSE_SOURCE enabled
+        // (default). The byte array reference should have been cleared from the
+        // ThreadLocal on close, so the second parse resets the unpacker and starts
+        // from the beginning rather than continuing from the end.
+        List<Integer> result = objectMapper.readValue(bytes, new TypeReference<List<Integer>>() {});
+        assertEquals(Arrays.asList(1, 2, 3), result);
+    }
 }