From 0c143ea2b92eadd923cdf51d0bf4b9e1d3d4a6db Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Fri, 22 May 2026 17:30:43 +0200 Subject: [PATCH 01/10] init config --- conf/defaults.yaml | 2 ++ .../src/jvm/org/apache/storm/Config.java | 21 +++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/conf/defaults.yaml b/conf/defaults.yaml index 2c3bb9e063..5374d44226 100644 --- a/conf/defaults.yaml +++ b/conf/defaults.yaml @@ -55,6 +55,8 @@ storm.nimbus.zookeeper.acls.fixup: true storm.auth.simple-white-list.users: [ ] storm.cluster.state.store: "org.apache.storm.cluster.ZKStateStorageFactory" storm.meta.serialization.delegate: "org.apache.storm.serialization.ZstdBridgeThriftSerializationDelegate" +topology.tuple.compression.threshold: 1460 +topology.tuple.compression.enable: false storm.compression.zstd.level: 3 storm.compression.zstd.max.decompressed.bytes: 104857600 storm.compression.gzip.max.decompressed.bytes: 104857600 diff --git a/storm-client/src/jvm/org/apache/storm/Config.java b/storm-client/src/jvm/org/apache/storm/Config.java index 0d70465858..a8d634b5cf 100644 --- a/storm-client/src/jvm/org/apache/storm/Config.java +++ b/storm-client/src/jvm/org/apache/storm/Config.java @@ -1485,6 +1485,27 @@ public class Config extends HashMap { */ @IsString public static final String STORM_META_SERIALIZATION_DELEGATE = "storm.meta.serialization.delegate"; + /** + * Topology configuration to enable compression of serialized tuples during inter-worker network transfer. + * When set to {@code true}, tuples emitted by this component will be compressed prior to being sent + * over the network to remote worker processes. This is highly recommended for topologies exchanging + * large payloads (e.g., entire lines of text or large data blocks) to significantly reduce network I/O. + * Default: {@code false} (Disabled by default to prevent unexpected CPU overhead). + */ + @IsBoolean + public static final String TOPOLOGY_TUPLE_COMPRESSION_ENABLE = "topology.tuple.compression.enable"; + /** + * Topology configuration specifying the minimum size threshold (in bytes) for compressing serialized tuples + * during inter-worker network transfer. + * When the serialized byte array of a tuple equals or exceeds this threshold, it will be compressed + * prior to being transmitted over the network to a remote worker process. This optimizes network I/O + * for large payloads (such as text blocks or massive objects) without wasting cycles on small data. + * Default: {@code 1460} bytes (The typical maximum segment size [MSS] for a standard + * Ethernet TCP payload, preventing compression on packets that already fit within a single network frame). + *

+ */ + @IsPositiveNumber + public static final String TOPOLOGY_TUPLE_COMPRESSION_THRESHOLD = "topology.tuple.compression.threshold"; /** * GZIP max decompression bytes. Defaults to 104857600 (100MB). */ From 5a0f72aa8abe803a60fec2b61666faa355a52597 Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Fri, 22 May 2026 17:51:44 +0200 Subject: [PATCH 02/10] (de)serialization logic --- .../serialization/KryoTupleDeserializer.java | 32 ++++++++++++++++--- .../serialization/KryoTupleSerializer.java | 30 ++++++++++++++--- 2 files changed, 53 insertions(+), 9 deletions(-) diff --git a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java index 0d9f6b9fe9..9dc4d7a5f2 100644 --- a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java +++ b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java @@ -16,27 +16,49 @@ import java.io.IOException; import java.util.List; import java.util.Map; +import org.apache.storm.Config; import org.apache.storm.task.GeneralTopologyContext; import org.apache.storm.tuple.MessageId; import org.apache.storm.tuple.TupleImpl; +import org.apache.storm.utils.ObjectReader; +import org.apache.storm.utils.Utils; public class KryoTupleDeserializer implements ITupleDeserializer { - private GeneralTopologyContext context; - private KryoValuesDeserializer kryo; - private SerializationFactory.IdDictionary ids; - private Input kryoInput; + private static final Integer DEFAULT_MAX_DECOMPRESSED_BYTES = 100 * 1024 * 1024; + private final GeneralTopologyContext context; + private final KryoValuesDeserializer kryo; + private final SerializationFactory.IdDictionary ids; + private final Input kryoInput; + private final int maxZstdDecompressedBytes; public KryoTupleDeserializer(final Map conf, final GeneralTopologyContext context) { kryo = new KryoValuesDeserializer(conf); this.context = context; ids = new SerializationFactory.IdDictionary(context.getRawTopology()); kryoInput = new Input(1); + maxZstdDecompressedBytes = ObjectReader.getInt(conf.get(Config.STORM_COMPRESSION_ZSTD_MAX_DECOMPRESSED_BYTES), DEFAULT_MAX_DECOMPRESSED_BYTES); } @Override public TupleImpl deserialize(byte[] ser) { try { - kryoInput.setBuffer(ser); + byte[] dataToProcess = ser; + + /* + * The official Zstandard magic header bytes (0x28, 0xB5, 0x2F, 0xFD), used to detect compressed payloads + * with zero network overhead. This approach is mathematically immune to protocol collisions because the + * initial bytes of an uncompressed Storm tuple are generated by Kryo's variable-length integer encoding + * (Varint) representing the positive {@code sourceTask} and {@code streamId}. While a Task ID of 40 can + * match the first Zstd byte ({@code 0x28}), the second Zstd byte ({@code 0xB5}, which has a Most Significant + * Bit of 1) cannot collide with the subsequent Stream ID, as small positive Varints strictly require a Most + * Significant Bit of 0. This structural incompatibility creates a unique binary fingerprint, allowing the + * deserializer to reliably distinguish data streams without allocating extra header bytes. + */ + if (Utils.ZstdUtils.isZstd(dataToProcess)) { + dataToProcess = Utils.ZstdUtils.decompress(dataToProcess, this.maxZstdDecompressedBytes); + } + + kryoInput.setBuffer(dataToProcess); int taskId = kryoInput.readInt(true); int streamId = kryoInput.readInt(true); String componentName = context.getComponentId(taskId); diff --git a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleSerializer.java b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleSerializer.java index 3b6a9f15a7..01f14c692e 100644 --- a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleSerializer.java +++ b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleSerializer.java @@ -14,19 +14,32 @@ import com.esotericsoftware.kryo.io.Output; import java.io.IOException; +import java.util.Arrays; import java.util.Map; +import org.apache.storm.Config; import org.apache.storm.task.GeneralTopologyContext; import org.apache.storm.tuple.Tuple; +import org.apache.storm.utils.ObjectReader; +import org.apache.storm.utils.Utils; public class KryoTupleSerializer implements ITupleSerializer { - private KryoValuesSerializer kryo; - private SerializationFactory.IdDictionary ids; - private Output kryoOut; + private static final int DEFAULT_COMPRESSION_THRESHOLD = 1460; + private static final Integer DEFAULT_ZSTD_COMPRESSION_LEVEL = 3; + + private final KryoValuesSerializer kryo; + private final SerializationFactory.IdDictionary ids; + private final Output kryoOut; + private final boolean isCompressionEnabled; + private final int compressionThreshold; + private final int zstdCompressionLevel; public KryoTupleSerializer(final Map conf, final GeneralTopologyContext context) { kryo = new KryoValuesSerializer(conf); kryoOut = new Output(2000, 2000000000); ids = new SerializationFactory.IdDictionary(context.getRawTopology()); + isCompressionEnabled = ObjectReader.getBoolean(conf.get(Config.TOPOLOGY_TUPLE_COMPRESSION_ENABLE), false); + compressionThreshold = ObjectReader.getInt(conf.get(Config.TOPOLOGY_TUPLE_COMPRESSION_THRESHOLD), DEFAULT_COMPRESSION_THRESHOLD); + zstdCompressionLevel = ObjectReader.getInt(conf.get(Config.STORM_COMPRESSION_ZSTD_LEVEL), DEFAULT_ZSTD_COMPRESSION_LEVEL); } @Override @@ -38,7 +51,16 @@ public byte[] serialize(Tuple tuple) { kryoOut.writeInt(ids.getStreamId(tuple.getSourceComponent(), tuple.getSourceStreamId()), true); tuple.getMessageId().serialize(kryoOut); kryo.serializeInto(tuple.getValues(), kryoOut); - return kryoOut.toBytes(); + + byte[] rawBytes = kryoOut.getBuffer(); + int dataLength = kryoOut.position(); + + if (this.isCompressionEnabled && dataLength > this.compressionThreshold) { + byte[] bytesToCompress = Arrays.copyOf(rawBytes, dataLength); + return Utils.ZstdUtils.compress(bytesToCompress, this.zstdCompressionLevel); + } else { + return Arrays.copyOf(rawBytes, dataLength); + } } catch (IOException e) { throw new RuntimeException(e); } From 56bb4419850980f1a51111e579e7838ab14f8acb Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Sat, 23 May 2026 11:37:02 +0200 Subject: [PATCH 03/10] deserialization logic refinement, unit tests --- .../serialization/KryoTupleDeserializer.java | 33 ++- .../KryoTupleSerializerDeserializerTest.java | 270 ++++++++++++++++++ 2 files changed, 286 insertions(+), 17 deletions(-) create mode 100644 storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java diff --git a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java index 9dc4d7a5f2..0d2b29ce53 100644 --- a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java +++ b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java @@ -41,24 +41,23 @@ public KryoTupleDeserializer(final Map conf, final GeneralTopolo @Override public TupleImpl deserialize(byte[] ser) { - try { - byte[] dataToProcess = ser; - - /* - * The official Zstandard magic header bytes (0x28, 0xB5, 0x2F, 0xFD), used to detect compressed payloads - * with zero network overhead. This approach is mathematically immune to protocol collisions because the - * initial bytes of an uncompressed Storm tuple are generated by Kryo's variable-length integer encoding - * (Varint) representing the positive {@code sourceTask} and {@code streamId}. While a Task ID of 40 can - * match the first Zstd byte ({@code 0x28}), the second Zstd byte ({@code 0xB5}, which has a Most Significant - * Bit of 1) cannot collide with the subsequent Stream ID, as small positive Varints strictly require a Most - * Significant Bit of 0. This structural incompatibility creates a unique binary fingerprint, allowing the - * deserializer to reliably distinguish data streams without allocating extra header bytes. - */ - if (Utils.ZstdUtils.isZstd(dataToProcess)) { - dataToProcess = Utils.ZstdUtils.decompress(dataToProcess, this.maxZstdDecompressedBytes); + if (Utils.ZstdUtils.isZstd(ser)) { + try { + byte[] decompressed = Utils.ZstdUtils.decompress(ser, this.maxZstdDecompressedBytes); + return deserializeTuple(decompressed); + } catch (RuntimeException e) { + // isZstd() false positive: a raw Kryo tuple's first 4 bytes matched ZSTD_MAGIC_HEADER by chance. + // This is mathematically impossible in practice: the first field is a varint taskId, whose + // valid range produces a first byte that never reaches 0xFD (the magic header's first byte). + // Branch retained for correctness in case assumptions about taskId range ever change. } + } + return deserializeTuple(ser); + } - kryoInput.setBuffer(dataToProcess); + private TupleImpl deserializeTuple(byte[] data) { + try { + kryoInput.setBuffer(data, 0, data.length); int taskId = kryoInput.readInt(true); int streamId = kryoInput.readInt(true); String componentName = context.getComponentId(taskId); @@ -67,7 +66,7 @@ public TupleImpl deserialize(byte[] ser) { List values = kryo.deserializeFrom(kryoInput); return new TupleImpl(context, values, componentName, taskId, streamName, id); } catch (IOException e) { - throw new RuntimeException(e); + throw new RuntimeException("Failed to deserialize tuple", e); } } } diff --git a/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java b/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java new file mode 100644 index 0000000000..62c5ebc693 --- /dev/null +++ b/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java @@ -0,0 +1,270 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. The ASF licenses this file to you 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.apache.storm.serialization; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.apache.storm.Config; +import org.apache.storm.generated.StormTopology; +import org.apache.storm.task.GeneralTopologyContext; +import org.apache.storm.testing.TestWordCounter; +import org.apache.storm.testing.TestWordSpout; +import org.apache.storm.topology.TopologyBuilder; +import org.apache.storm.tuple.Fields; +import org.apache.storm.tuple.MessageId; +import org.apache.storm.tuple.TupleImpl; +import org.apache.storm.tuple.Values; +import org.apache.storm.utils.Utils; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +/** + * Unit tests for {@link KryoTupleSerializer} and {@link KryoTupleDeserializer}, covering the compressed and + * uncompressed code paths, round-trip fidelity, mixing both encodings through a single (de)serializer instance, + * and the negative/error paths. + */ +public class KryoTupleSerializerDeserializerTest { + + private static final String SOURCE_COMPONENT = "1"; + private static final String DEST_COMPONENT = "2"; + private static final int SOURCE_TASK_ID = 1; + + private GeneralTopologyContext context; + + @BeforeEach + public void setup() { + StormTopology topology = createStormTopology(); + context = mock(GeneralTopologyContext.class); + when(context.getRawTopology()).thenReturn(topology); + when(context.getComponentId(SOURCE_TASK_ID)).thenReturn(SOURCE_COMPONENT); + when(context.doSanityCheck()).thenReturn(false); + } + + private StormTopology createStormTopology() { + TopologyBuilder builder = new TopologyBuilder(); + builder.setSpout(SOURCE_COMPONENT, new TestWordSpout(true), 1); + builder.setBolt(DEST_COMPONENT, new TestWordCounter(), 1).fieldsGrouping(SOURCE_COMPONENT, new Fields("word")); + return builder.createTopology(); + } + + private Map baseConf() { + return new HashMap<>(Utils.readStormConfig()); + } + + private Map compressionEnabledConf(int threshold) { + Map conf = baseConf(); + conf.put(Config.TOPOLOGY_TUPLE_COMPRESSION_ENABLE, true); + conf.put(Config.TOPOLOGY_TUPLE_COMPRESSION_THRESHOLD, threshold); + conf.put(Config.STORM_COMPRESSION_ZSTD_LEVEL, 3); + return conf; + } + + @Test + public void testRoundTripUncompressedWhenCompressionDisabled() { + Map conf = baseConf(); // compression disabled by default + KryoTupleSerializer serializer = new KryoTupleSerializer(conf, context); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(conf, context); + + TupleImpl original = tuple(new Values("hello", 42, bigString(8192)), MessageId.makeRootId(7L, 99L)); + byte[] bytes = serializer.serialize(original); + + assertFalse(Utils.ZstdUtils.isZstd(bytes), "compression disabled must never emit a zstd frame"); + assertSameTuple(original, deserializer.deserialize(bytes)); + } + + @Test + public void testRoundTripUncompressedWhenBelowThreshold() { + Map conf = compressionEnabledConf(1460); + KryoTupleSerializer serializer = new KryoTupleSerializer(conf, context); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(conf, context); + + TupleImpl original = tuple(new Values("small", 1), MessageId.makeUnanchored()); + byte[] bytes = serializer.serialize(original); + + assertFalse(Utils.ZstdUtils.isZstd(bytes), "payload below threshold must not be compressed"); + assertSameTuple(original, deserializer.deserialize(bytes)); + } + + @Test + public void testRoundTripCompressedWhenAboveThreshold() { + Map conf = compressionEnabledConf(1460); + KryoTupleSerializer serializer = new KryoTupleSerializer(conf, context); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(conf, context); + + TupleImpl original = tuple(new Values(bigString(64 * 1024)), MessageId.makeRootId(5L, 11L)); + byte[] bytes = serializer.serialize(original); + + assertTrue(Utils.ZstdUtils.isZstd(bytes), "payload above threshold must be compressed"); + assertSameTuple(original, deserializer.deserialize(bytes)); + } + + @Test + public void testCompressionAtExactThreshold() { + Map conf = compressionEnabledConf(0); + KryoTupleSerializer serializer = new KryoTupleSerializer(conf, context); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(conf, context); + + TupleImpl original = tuple(new Values("x"), MessageId.makeUnanchored()); + byte[] bytes = serializer.serialize(original); + + assertTrue(Utils.ZstdUtils.isZstd(bytes), "threshold 0 must compress every non-empty payload"); + assertSameTuple(original, deserializer.deserialize(bytes)); + } + + @Test + public void testMixedCompressedAndUncompressedSameInstances() { + Map conf = compressionEnabledConf(1460); + KryoTupleSerializer serializer = new KryoTupleSerializer(conf, context); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(conf, context); + + TupleImpl small = tuple(new Values("tiny", 1), MessageId.makeRootId(1L, 2L)); + TupleImpl large = tuple(new Values(bigString(32 * 1024), "tail"), MessageId.makeRootId(3L, 4L)); + + // Buffer reuse across compressed and uncompressed payloads. + byte[] smallBytes1 = serializer.serialize(small); + byte[] largeBytes1 = serializer.serialize(large); + byte[] smallBytes2 = serializer.serialize(small); + byte[] largeBytes2 = serializer.serialize(large); + + assertFalse(Utils.ZstdUtils.isZstd(smallBytes1)); + assertTrue(Utils.ZstdUtils.isZstd(largeBytes1)); + assertFalse(Utils.ZstdUtils.isZstd(smallBytes2)); + assertTrue(Utils.ZstdUtils.isZstd(largeBytes2)); + + // deserializer must transparently handle both encodings, in any order. + assertSameTuple(large, deserializer.deserialize(largeBytes1)); + assertSameTuple(small, deserializer.deserialize(smallBytes1)); + assertSameTuple(small, deserializer.deserialize(smallBytes2)); + assertSameTuple(large, deserializer.deserialize(largeBytes2)); + } + + @Test + public void testCompressedTupleDeserializedWhenDeserializerCompressionDisabled() { + KryoTupleSerializer serializer = new KryoTupleSerializer(compressionEnabledConf(0), context); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(baseConf(), context); + + TupleImpl original = tuple(new Values(bigString(16 * 1024)), MessageId.makeRootId(8L, 9L)); + byte[] bytes = serializer.serialize(original); + + assertTrue(Utils.ZstdUtils.isZstd(bytes)); + assertSameTuple(original, deserializer.deserialize(bytes)); + } + + // corner cases + + @Test + public void testRoundTripEmptyValues() { + Map conf = baseConf(); + KryoTupleSerializer serializer = new KryoTupleSerializer(conf, context); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(conf, context); + + TupleImpl original = tuple(new Values(), MessageId.makeUnanchored()); + TupleImpl result = deserializer.deserialize(serializer.serialize(original)); + assertSameTuple(original, result); + assertTrue(result.getValues().isEmpty()); + } + + @Test + public void testRoundTripNullValue() { + Map conf = baseConf(); + KryoTupleSerializer serializer = new KryoTupleSerializer(conf, context); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(conf, context); + + TupleImpl original = tuple(new Values("a", null, "b"), MessageId.makeUnanchored()); + assertSameTuple(original, deserializer.deserialize(serializer.serialize(original))); + } + + // negative tests + + @Test + public void testDeserializeGarbageBytesThrows() { + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(baseConf(), context); + // Not a zstd frame (length < 4 keeps isZstd false) and not a valid kryo tuple. + assertThrows(RuntimeException.class, () -> deserializer.deserialize(new byte[]{1, 2, 3})); + } + + @Test + public void testDeserializeEmptyBytesThrows() { + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(baseConf(), context); + assertThrows(RuntimeException.class, () -> deserializer.deserialize(new byte[0])); + } + + @Test + public void testDeserializeZstdMagicButInvalidFrameThrows() { + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(baseConf(), context); + // First 4 bytes are the little-endian zstd magic 0xFD2FB528 so isZstd() is true, but the rest is + // not a valid zstd frame. decompress() throws, the false-positive fallback re-parses the raw bytes, + // which are also not a valid kryo tuple -> RuntimeException. + byte[] fakeZstd = new byte[]{(byte) 0x28, (byte) 0xB5, (byte) 0x2F, (byte) 0xFD, 0x00, 0x01, 0x02, 0x03}; + assertTrue(Utils.ZstdUtils.isZstd(fakeZstd)); + assertThrows(RuntimeException.class, () -> deserializer.deserialize(fakeZstd)); + } + + @Test + public void testDeserializeCompressedExceedingMaxDecompressedBytesThrows() { + // A genuinely compressed tuple, but the deserializer is configured with a tiny decompression cap. + // decompress() throws ("threshold exceeded"), the fallback re-parses the still-compressed raw bytes, + // which are not a valid kryo tuple -> RuntimeException. + KryoTupleSerializer serializer = new KryoTupleSerializer(compressionEnabledConf(0), context); + Map deserConf = baseConf(); + deserConf.put(Config.STORM_COMPRESSION_ZSTD_MAX_DECOMPRESSED_BYTES, 1); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(deserConf, context); + + byte[] bytes = serializer.serialize(tuple(new Values(bigString(8192)), MessageId.makeUnanchored())); + assertTrue(Utils.ZstdUtils.isZstd(bytes)); + assertThrows(RuntimeException.class, () -> deserializer.deserialize(bytes)); + } + + @Test + public void testSerializeUnregisteredTypeWithoutJavaFallbackThrows() { + Map conf = baseConf(); + conf.put(Config.TOPOLOGY_FALL_BACK_ON_JAVA_SERIALIZATION, false); + KryoTupleSerializer serializer = new KryoTupleSerializer(conf, context); + + TupleImpl original = tuple(new Values(new UnregisteredType()), MessageId.makeUnanchored()); + assertThrows(RuntimeException.class, () -> serializer.serialize(original)); + } + + private static class UnregisteredType { + @SuppressWarnings("unused") + private final int field = 1; + } + + private TupleImpl tuple(List values, MessageId id) { + return new TupleImpl(context, values, SOURCE_COMPONENT, SOURCE_TASK_ID, Utils.DEFAULT_STREAM_ID, id); + } + + private void assertSameTuple(TupleImpl expected, TupleImpl actual) { + assertEquals(expected.getValues(), actual.getValues()); + assertEquals(expected.getSourceTask(), actual.getSourceTask()); + assertEquals(expected.getSourceComponent(), actual.getSourceComponent()); + assertEquals(expected.getSourceStreamId(), actual.getSourceStreamId()); + assertEquals(expected.getMessageId(), actual.getMessageId()); + } + + private String bigString(int size) { + StringBuilder sb = new StringBuilder(size); + for (int i = 0; i < size; i++) { + sb.append((char) ('a' + (i % 26))); + } + return sb.toString(); + } +} From 7ec226352f38bb9be0d106e8b745662ae0dfecae Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Sat, 23 May 2026 12:07:24 +0200 Subject: [PATCH 04/10] docs + storm perf example --- docs/Serialization.md | 40 ++++++++ ...FileReadWordCountSpoutCompressionTopo.java | 94 +++++++++++++++++++ .../src/main/sampledata/longrandomwords.txt | 50 ++++++++++ .../serialization/KryoTupleDeserializer.java | 3 +- 4 files changed, 186 insertions(+), 1 deletion(-) create mode 100644 examples/storm-perf/src/main/java/org/apache/storm/perf/FileReadWordCountSpoutCompressionTopo.java create mode 100644 examples/storm-perf/src/main/sampledata/longrandomwords.txt diff --git a/docs/Serialization.md b/docs/Serialization.md index 0e7cc2e87a..a90840e704 100644 --- a/docs/Serialization.md +++ b/docs/Serialization.md @@ -61,6 +61,46 @@ Beware that Java serialization is extremely expensive, both in terms of CPU cost You can turn on/off the behavior to fall back on Java serialization by setting the `Config.TOPOLOGY_FALL_BACK_ON_JAVA_SERIALIZATION` config to true/false. The default value is false for security reasons. +### Tuple compression + +For inter-worker (remote) traffic, Storm can optionally compress serialized tuples with [Zstandard](https://facebook.github.io/zstd/) before they are sent over the network. This is intended for one specific scenario: components that emit **large** payloads to a remote worker, where the bytes saved on the wire outweigh the CPU cost of compression. A good example is a spout that emits entire lines of text to a downstream bolt running on a different worker. + +Compression is **disabled by default** and follows the serialization lifecycle exactly: + +- **Intra-worker (local) traffic** bypasses `KryoTupleSerializer` altogether, so it is never compressed regardless of configuration. You do not pay any CPU cost for tuples that stay inside a worker process. +- **Inter-worker (remote) traffic** is compressed only when compression is enabled for the source component *and* the serialized tuple is larger than the configured threshold. Small tuples (single words, IDs, etc.) are left uncompressed, since the framing overhead of a compressed payload can exceed the original size. + +#### Enabling compression per component + +Compression is controlled by the component-specific configuration `topology.tuple.compression.enable`. Because Storm merges component-specific configuration over the topology configuration, you can enable it for just the components that emit large tuples, leaving the rest of the topology untouched: + +```java +TopologyBuilder builder = new TopologyBuilder(); + +builder.setSpout(SPOUT_ID, new FileReadSpout(inputFile), spoutNum) + .addConfiguration(Config.TOPOLOGY_TUPLE_COMPRESSION_ENABLE, true); + +builder.setBolt(SPLIT_ID, new SplitSentenceBolt(), spBoltNum) + .localOrShuffleGrouping(SPOUT_ID); +builder.setBolt(COUNT_ID, new CountBolt(), cntBoltNum) + .fieldsGrouping(SPLIT_ID, new Fields(SplitSentenceBolt.FIELDS)); +``` + +You can also enable it topology-wide (or cluster-wide via `storm.yaml`) by setting `topology.tuple.compression.enable: true`, but enabling it only where large tuples are actually emitted is recommended. + +#### Configuration reference + +| Config | Default | Description | +| --- | --- | --- | +| `topology.tuple.compression.enable` | `false` | Enables Zstd compression of serialized tuples before remote transfer. Best set per component via `addConfiguration`. | +| `topology.tuple.compression.threshold` | `1460` | Minimum serialized tuple size, in bytes, before compression is attempted. Tuples at or below this size are sent uncompressed. The default matches the typical Ethernet TCP MSS, so payloads that already fit in a single network frame are never compressed. | +| `storm.compression.zstd.level` | `3` | Zstd compression level. Supported range is 1–19; levels 20–22 (ultra mode) are prohibited because of their memory requirements. | +| `storm.compression.zstd.max.decompressed.bytes` | `104857600` (100 MB) | Upper bound on the decompressed size of a single tuple. Decompression that would exceed this limit fails, guarding against malicious or corrupt payloads. | + +#### How decompression works + +Compression is self-describing on the wire, so **no configuration is required on the receiving side**. The deserializer inspects the leading bytes of each incoming payload: if they match the Zstd magic header it decompresses the payload (bounded by `storm.compression.zstd.max.decompressed.bytes`) before deserializing, otherwise it deserializes the bytes directly. This means a single deserializer transparently handles a mix of compressed and uncompressed tuples, and a worker that does not enable compression can still receive compressed tuples from one that does. + ### Component-specific serialization registrations Storm 0.7.0 lets you set component-specific configurations (read more about this at [Configuration](Configuration.html)). Of course, if one component defines a serialization that serialization will need to be available to other bolts -- otherwise they won't be able to receive messages from that component! diff --git a/examples/storm-perf/src/main/java/org/apache/storm/perf/FileReadWordCountSpoutCompressionTopo.java b/examples/storm-perf/src/main/java/org/apache/storm/perf/FileReadWordCountSpoutCompressionTopo.java new file mode 100644 index 0000000000..3c2f538c4b --- /dev/null +++ b/examples/storm-perf/src/main/java/org/apache/storm/perf/FileReadWordCountSpoutCompressionTopo.java @@ -0,0 +1,94 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.storm.perf; + +import java.util.Map; +import org.apache.storm.Config; +import org.apache.storm.generated.StormTopology; +import org.apache.storm.perf.bolt.CountBolt; +import org.apache.storm.perf.bolt.SplitSentenceBolt; +import org.apache.storm.perf.spout.FileReadSpout; +import org.apache.storm.perf.utils.Helper; +import org.apache.storm.topology.TopologyBuilder; +import org.apache.storm.tuple.Fields; +import org.apache.storm.utils.Utils; + +/** + * This topo helps measure speed of word count. + * + *

Spout loads a file into memory on initialization, then emits the lines in an endless loop. + */ +public class FileReadWordCountSpoutCompressionTopo { + public static final String SPOUT_ID = "spout"; + public static final String COUNT_ID = "counter"; + public static final String SPLIT_ID = "splitter"; + public static final String TOPOLOGY_NAME = "FileReadWordCountTopo"; + + // Config settings + public static final String SPOUT_NUM = "spout.count"; + public static final String SPLIT_NUM = "splitter.count"; + public static final String COUNT_NUM = "counter.count"; + public static final String INPUT_FILE = "input.file"; + + public static final int DEFAULT_SPOUT_NUM = 1; + public static final int DEFAULT_SPLIT_BOLT_NUM = 2; + public static final int DEFAULT_COUNT_BOLT_NUM = 2; + + + static StormTopology getTopology(Map config) { + + final int spoutNum = Helper.getInt(config, SPOUT_NUM, DEFAULT_SPOUT_NUM); + final int spBoltNum = Helper.getInt(config, SPLIT_NUM, DEFAULT_SPLIT_BOLT_NUM); + final int cntBoltNum = Helper.getInt(config, COUNT_NUM, DEFAULT_COUNT_BOLT_NUM); + final String inputFile = Helper.getStr(config, INPUT_FILE); + + TopologyBuilder builder = new TopologyBuilder(); + // sampledata/longrandomwords.txt contains sentences with at least 1500 bytes + builder.setSpout(SPOUT_ID, new FileReadSpout(inputFile), spoutNum) + .addConfiguration(Config.TOPOLOGY_TUPLE_COMPRESSION_ENABLE, true); + builder.setBolt(SPLIT_ID, new SplitSentenceBolt(), spBoltNum).localOrShuffleGrouping(SPOUT_ID); + builder.setBolt(COUNT_ID, new CountBolt(), cntBoltNum).fieldsGrouping(SPLIT_ID, new Fields(SplitSentenceBolt.FIELDS)); + + return builder.createTopology(); + } + + public static void main(String[] args) throws Exception { + int runTime = -1; + Config topoConf = new Config(); + if (args.length > 0) { + runTime = Integer.parseInt(args[0]); + } + if (args.length > 1) { + topoConf.putAll(Utils.findAndReadConfigFile(args[1])); + } + topoConf.put(Config.TOPOLOGY_PRODUCER_BATCH_SIZE, 1000); + topoConf.put(Config.TOPOLOGY_BOLT_WAIT_STRATEGY, "org.apache.storm.policy.WaitStrategyPark"); + topoConf.put(Config.TOPOLOGY_BOLT_WAIT_PARK_MICROSEC, 0); + topoConf.put(Config.TOPOLOGY_DISABLE_LOADAWARE_MESSAGING, true); + topoConf.put(Config.TOPOLOGY_STATS_SAMPLE_RATE, 0.0005); + + topoConf.putAll(Utils.readCommandLineOpts()); + if (args.length > 2) { + System.err.println("args: [runDurationSec] [optionalConfFile]"); + return; + } + // Submit topology to storm cluster + Helper.runOnClusterAndPrintMetrics(runTime, TOPOLOGY_NAME, topoConf, getTopology(topoConf)); + } +} diff --git a/examples/storm-perf/src/main/sampledata/longrandomwords.txt b/examples/storm-perf/src/main/sampledata/longrandomwords.txt new file mode 100644 index 0000000000..e50c25207f --- /dev/null +++ b/examples/storm-perf/src/main/sampledata/longrandomwords.txt @@ -0,0 +1,50 @@ +bacterioblast neurotrophic ventricous involatile trillion oflete splenauxe Vichyite scabbiness antiscolic unpredict mastication glacierist theologal tetchy sapphiric unchatteled elemicin dastardliness apocalypst untongued prefatorial Edo preparative experientialist Spatangoidea unfulminated orgiastic pneumatotherapy Mycogone nonpoisonous bespin Jerusalem benthonic antihero zenick supermarket divinator coadvice abscission zanyism inductivity subdentate pneumonalgia pyrocatechol nebular friarhood unreprimanded Joachimite yeat subdrainage sirrah charioteer euphonym feasibleness boser minniebush seizing unrealize Helvidian plugger Confervales Filipendula venialness migrainoid undercolored pneumatotherapy Jerusalem helpless quadrennial tartrous sapience opacousness autoschediastical theologicopolitical paleornithology codisjunct laryngic goladar nonrepetition diathermacy dithery cocksuredom Spatangoidea unscourged orthopedical oxyterpene ovopyriform stachyuraceous metaphrastical lineamental concretion atlantite impairment unharmed constitutor misexposition oratorship bladderwort toxoplasmosis jajman diminutively sequacity twinling velaric Muscicapa redescend astucious subdentate digitule glacierist authorling Pyrales imaginary tambo nigh deaf swacking avengeful bathysphere undeterring decidable repealableness Bassaris omniscribent metastoma guitarist interruptedness pentagamist corelysis subtransverse basto drome bismuthiferous massedly wemless dipsomaniacal uninterpleaded Macraucheniidae +meloplasty Dodecatheon nonrepetition coadvice taurocolla eternal Fouquieria retinize quadrennial provedore serpentinic planosubulate downthrust widdle epauliere chooser ethmopalatal groundneedle ladhood elastivity cloy guitarist bozal undiffusive eternal tristich familist counteralliance antivenin redecrease meriquinoidal Bermudian paranephros projecting scrat scrubbed monander propodiale planosubulate halloo emir oratorship slait eurythermal unsupercilious tetragynian antideflation unsupercilious glaumrie ell throbless misexposition allegedly allectory sialadenitis trailmaking tricae bucketer Joachimite quadrennial wherefrom pamphlet hysterogen shibuichi gunshop angiopathy parquet depravity chordacentrum mechanist overcontribute thermanesthesia debellator arteriasis topsail elastivity commandingness stereotypography velaric chordacentrum collegian overwoven tramplike thermanesthesia parmelioid dishpan limpet flatman allotropic neuromimesis porencephalous iniquitously subfoliar tomorrowness macropterous ungrave meloplasty myesthesia cyanophilous Hydrangea trip potentness stapedius toxoplasmosis schoolmasterism Florissant bought dishpan Sphenodontidae flushgate uncontradictableness projecting Aplacentalia experientialist overcontribute swoony inexistency barkometer pneumatotherapy bought subdrainage manilla circumzenithal Lincolnlike synovial Florissant thermochemically dunkadoo toxoplasmosis cobeliever Mycogone Kenipsim frameable unefficient twinling redecrease supermarket bugre +nonutilitarian galbulus snare slait pope Scanic overinstruct tramplike Bushongo Bassaris foursquare Orbitolina rebilling corbel transcorporeal allotropic Coniferae benthonic chordacentrum templar porriginous refasten testa misthread euphonym naught theologal thorite blurredness starosta unstressedly semiangle subfoliar doubtingness manny sonable seraphism archistome prescriptible pyxie epauliere pomiferous unforkedness Kenipsim alveolite dipsomaniacal admissory allotropic ethnocracy trophonema hoove macropterous elastivity perculsive pyrocatechol sonable zoonitic omega various evictor dispermy Pishquow ipomoein liberatress Consolamentum schoolmasterism laryngic smokefarthings regardful tambo quailberry rede reformatory testa tricae superindifference halloo ineunt omniscribent oblongly percent ladhood sud Ophiosaurus glyphography generalizable edificator sloped serphoid allectory Thraupidae unurban zanyism plerome swoony playfellowship octogynous bunghole expiscate superindifference warriorwise becomma nativeness tickleproof inferent manganosiderite undecorated nectopod nummi licitness umbellic unanatomized pachydermatoid genii rede michigan iniquitously bot serphoid Jerusalem bromic pachydermatoid upswell fallacious parquet unfulminated comism reeveland nonprofession bacterioblast unexplicit unpremonished antihero Oryzorictinae shibuichi unisexuality sterilely cornberry commandingness undiffusive columniform uncontradictableness divinator cockal crystallographical Bermudian sturdied +havoc regardful angiopathy Cercosporella benzoperoxide imaginary waird dialoguer exploiter tambo lineamental cheesecutter Scorpaenidae subdrainage cartful embryotic unleavened uncontradictableness vinegarish quarried dosseret beatable signifier impugnation Scanic playfellowship scotale Hydrangea quadrennial unpatched introducer unswanlike mericarp peptonate euphemious lammy phoenicochroite Lincolnlike figured times allotropic frenal arduousness imprescribable Vichyite allotropic valvulotomy laurinoxylon preparative exploiter aneurism outwealth adz balanocele reconciliable analgize Savitar Auriculariales ultratense pentafid serosanguineous reappreciate centrifugalization ungrave lammy lebensraum mesymnion paradisean ornithodelphous overinstruct oratorize perculsive bacillite glacierist unscourged louse nonrepetition quarried Orbitolina preaffiliate beneficent spermaphyte exploiter pachydermous upswell unobservantness bicorporeal archididascalian arsenide counteractively autoschediastical mastication preagitate sturdied cervisial reappreciate electrotechnics sapience horsefly topline glyphography prezygapophysial floatability temporomastoid almud adscendent incomprehensible naprapath depthwise ramosopalmate chargeably phlogisticate beadroll disilane Hysterocarpus nummi hackneyed serphoid eurythermal pansophism morphiomania heliocentricism tailoress excerpt autoschediastical pansophism eucalypteol archesporial whittle abthainry fetlocked phytoma dinical redesertion theologicopolitical +euphonym monander psychofugal semiangle autobiographist kenno euphonym danseuse nonutilitarian poleax biopsic placatory hackneyed tristich papery orthopedical diopside Tsonecan chargeably biodynamics transcorporeal Socraticism parmelioid pentosuria nonutilitarian shellworker collegian ordinant testa antiadiaphorist twinling predisputant bot spermaphyte oratorship cuproiodargyrite bismuthiferous ultrasystematic gallybeggar marten hackneyed unrealize twinling velaric discipular hoove sawdust inexistency reperuse Edo posterishness swangy haply Tsonecan timbermonger macropterous times adatom chronist knob pyroacetic inventurous squit tetrahedral nummi hyocholic redescend benzothiofuran oflete serpentinic abthainry neuromimesis jirble columniform Gothish rivethead selectivity stronghearted marshiness impressor winterproof benzothiofuran Hydrangea winterproof predisputant bettermost hypoplastral cyanophilous blurredness countergabion abscission orgiastic periarthritis posttraumatic fossilism obispo parquet alveolite naught nonrepetition overinstruct pelvimetry unimmortal bespin feasibleness angiopathy hymnic acidophile terrificness unlapsing masa champer angina serosanguineous porriginous uninhabitedness blightbird magnetooptics unstipulated Hydrangea eer outhue insatiately rebilling Muscicapa regardful Haversian wemless ploration interruptor chordacentrum semiangle Gilaki commotion eurythermal refective arval incomprehensible shibuichi testa refasten yote proauction Itea antalgol abthainry +ovopyriform rivethead Pithecolobium corbel pleasurehood dithery guanajuatite tramplike asparaginic epididymitis arrowworm hepatorrhaphy Eryon neurotrophic lophotrichic unstressedly Joachimite plugger trip vinegarish nonmanufacture nigh trunnel cobeliever packsack diplomatize uninductive absvolt undangered Itea eucalypteol tartrous weism infravaginal transude aquiline eternal unbashfulness eurythermal theologicopolitical sviatonosite uncarefully infestation Dadaism cuproiodargyrite biopsic overcultured approbation pyrocatechol massedly Helvidian timbermonger pyrocatechol redesertion nonprofession overcontribute archistome raphis louse nummi ovoviviparous propodiale Tsonecan agglomeratic pansophism orthopedical Florissant Ghent preparative nonutilitarian constitutor engrain totaquina packsack depthwise socioromantic plerome trisilicic percent debellator comprovincial japanned dithery sawdust winterproof balladmonger cockal trailmaking oxyterpene aconitine Dunlop unpeople circumzenithal quad aconitine liquidity uncombable stapedius cheesecutter byroad sturdied ten nonsuppressed patroller uninterpleaded breadwinner untongued noreast symbiogenetically phytoma retinize allotropic sawdust mammonish unschematized prefatorial signifier sequestrum biodynamics sawdust bromic kenno bathysphere chronist Thraupidae obispo preaffiliate preoral Alethea kerykeion unanatomized abusiveness blightbird pompiloid Effie benzoperoxide devilwise stachyuraceous besagne micromembrane extraorganismal exprobratory +unurban docimastical Triconodonta Ghent collegian tautness figured sombreroed pompiloid papery cockstone biodynamics ununiformly unfeeble eternal rechar papery subfoliar plugger schoolmasterism focaloid monstership dunkadoo parabolicness obolus heavenful antiabolitionist arrowworm dithery hellbender myesthesia untongued chrysochrous depravity stereotypography photoelasticity scotale overinstruct stronghearted tickleproof periarthritis experientialist bugre preaffiliate participatingly hondo Confervales sedentariness toplike seeingness reappreciate helminthagogic nonuple slipped antiabolitionist flippantness decardinalize opacousness obolus octogynous eurythermal toplike infrastapedial haply gelatinousness waird Joachimite opacousness involatile crystallographical Swaziland Vichyite trophonema silicize plugger cocksuredom omniscribent benthonic tetchy squdge merciful wandoo centrifugalization airfreighter steprelationship Itea omniscribent saponaceous raphis chrysochrous basto boor laryngic octogynous chargeably interruptor besagne snare ovopyriform sural chilblain unforkedness oinomancy Vaishnavism dermorhynchous reconciliable sapience chrysochrous manganosiderite trophonema unrevolting allectory reeveland unachievable ineunt bettermost ipomoein ten merciful debromination astucious times quadrennial Kenipsim seraphism cresylite bestill tristich paunchy ethnocracy harr absvolt Vichyite Italical rehabilitative warlike nebular ungreat templar uniarticular uninterpleaded chilblain +omniscribent acidophile erythrodextrin Dictograph instructiveness experientialist focaloid basto psychofugal epidymides Homoiousian wandoo meloplasty monilioid shellworker slipped antalgol scotale interfraternal rotular misthread posterishness appetible misexposition arrendation pleurotropous cocksuredom bromic Florissant ethnocracy angiolymphoma sangaree pyroacetic Tsonecan osteopaedion unurban gunshop plerome byroad placatory obolus noncrystallized oxyterpene lammy quintette rehabilitative cloy Spatangoidea adscendent uniarticular preoral undercolored phoenicochroite wingable sedentariness manny Llandovery coadvice Hester Arneb opacousness comism ununiformly unefficient almud serpentinic unpremonished trabecular ovopyriform licitness exprobratory cockstone helminthagogic noreast Vichyite starosta speckedness emir times debromination reconciliable propodiale penult emir spiciferous parmelioid evictor Tsonecan genii farrantly imprescribable merciful deepmost rizzomed redescend orgiastic unisexuality triakistetrahedral sialadenitis Protestantize detractive twinling ultraobscure nonpoisonous enterostomy eer seditious insatiately inexistency classificational subfebrile underskin brooky hyocholic unswanlike exploiter Helvidian laryngic pansophism dispermy oversand testa unpeople endotheliomyoma Sebastian waird splenauxe engrain hysterogen bromate redecrease impairment pneumatotherapy barkometer migrainoid predebit deepmost amylogenesis osteopaedion ten laubanite lifter Mormyrus porriginous +myesthesia ell glandularly bugre seraphism undercolored mustafina transcorporeal subfoliar reciprocation serphoid omniscribent redecrease detractive terrestrially starer temporomastoid comparability Pishquow sapphiric topline serpentinic Edo octogynous planosubulate timbermonger cacuminal weism umangite warlike Russifier wandoo cumbrousness Whilkut silverhead predebit bicorporeal Edo putative technopsychology Dictograph approbation noreast uninductive ferrogoslarite prezygapophysial shallowish shellworker biventer metopon palaeotheriodont Lincolnlike subfoliar proauction oxyterpene undinted mericarp propheticism Mormyrus phallaceous Muscicapa unburnt wherefrom subfoliar helpless Whilkut cockal involatile spiranthic Whilkut Passiflorales quadrennial nonuple redecrease tantivy cumbrousness glyphography tartrous cuproiodargyrite Ludgatian danseuse kenno seelful defensibly trailmaking greave figured timbermonger Serrifera scotching sirrah Oryzorictinae horsefly predebit sportswomanship stiffish spookdom unexplicit flutist reeveland yeat manny epididymitis vesperal autoschediastical characinoid Prosobranchiata ineunt impairment outhue precostal squit tetragynian prefatorial tricae bot swearingly oversand terrestrially uvanite Prosobranchiata homeotypical rechar critically cobeliever trip refasten mammonish outwealth beadroll chorograph bismuthiferous besagne transcortical starosta micromembrane stewardship champer underskin unburnt laurinoxylon enhedge micromembrane taurocolla uninterpleaded +stronghearted depressingly lithograph aprosopia parodist bought velaric analgize epauliere ipomoein swearingly macropterous taver osteopaedion greave hysterolysis visceral uninterpleaded piquantness benthonic fossilism phoenicochroite devilwise bonze pamphlet preoral depravity scotale chronographic overbuilt bot parodist poleax tristich unimmortal bought repealableness Semecarpus louse Endomycetaceae apopenptic reformatory tendomucoid soorkee parabolicness mesymnion orgiastic cubby rechar obolus Sphenodontidae metrocratic nonsuppressed lyrebird diatomaceous manganosiderite undangered antiadiaphorist triradiated umbellic misthread unharmed penult sleigher unachievable astronomize saponaceous archesporial hoove allotropic metaphonical putative entame bonze Scanic unscourged saponaceous pondside Serrifera seditious unfulminated preaffiliate relaster tartrous cresylite japanned immatchable limpet goodwill Endomycetaceae potentness havoc unfeeble calycular speckedness wingable rede putative squdge aurothiosulphuric paunchy hellbender subdrainage giantly rivethead perculsive culm Homoiousian slangy inventurous zoonitic times unstressedly bicorporeal marshiness charioteer orgiastic migrainoid gymnastic dunkadoo photoelasticity Pincian ethnocracy oratorize precostal tantivy expiscate seminonflammable bunghole nonpoisonous metaphonical spiranthic nummi groundneedle oinomancy unchatteled angina neurotrophic steprelationship tendomucoid Dodecatheon sedentariness minniebush elemicin outhue +rivethead soorkee uncarefully collegian uncompromisingly cacuminal cumbrousness uncompromisingness Aplacentalia subfebrile coadvice tetchy pleurotropous boser stroking vinegarish ovoviviparous overstudiousness suspend dishpan nigh oinomancy shibuichi coracomandibular pendulant Pithecolobium Dawsonia gorilloid agglomeratic redesertion frictionlessly redesertion opacousness entame pleasurehood putative epidymides morphiomania flatman ultratense liberatress percent strander tendomucoid tingly pentosuria Saponaria unfurbelowed subfoliar unfeeble mendacity tricae marten chronographic characinoid uncompromisingly omniscribent dermorhynchous affaite unfurbelowed glandularly lineamental glyphography Isokontae epauliere chasmy unleavened homeotypical antiadiaphorist Spatangoidea Hydrangea overstaid benzoperoxide engrain ovoviviparous uncompromisingness unscourged impairment pondside parmelioid templar benzothiofuran Cephalodiscus furacious discipular ticktick Quakerishly interfraternal glandularly homotransplant saponaceous gelatinousness socioromantic Lentibulariaceae chasmy sedentariness besagne sheepskin manganosiderite stentorophonic hysterogen Tsonecan phoenicochroite goladar glossing counteractively ungreat symbiogenetically relaster diplomatize winterproof comism helpless guanajuatite stiffish overwoven glandularly adatom unfurbelowed chordacentrum depravity parquet electrotechnics unharmed phlogisticate schoolmasterism unprovided unfurbelowed oversand corelysis crystallographical +unrevolting unobservantness stapedius tum serosanguineous clanned ventricous times winterproof overinstruct waird reeveland metoxazine approbation aquiline antalgol besagne mesophyte depressingly enterostomy erythrodextrin heavenful excerpt yawler interruptor bacillite collegian sonable frenal squdge entame galbulus Florissant propodiale cinque incomprehensible totaquina pachydermatoid plugger mustafina unprovided umbellic preagitate unanatomized counteractively relaster Italical spot Triphora nativeness seelful cornberry porriginous psychofugal abscission slangy rehabilitative bestill snare obolus underskin Italical undiffusive eristically lifter acocotl Bassaris mericarp uvanite outguess ineunt unstipulated overbuilt Dictograph uvanite characinoid Tsonecan cheesecutter debromination Fameuse rosaniline cloy noreast starer cheesecutter horsefly macropterous sequentially unburnt pictorially Triphora cyanoguanidine limpet biventer tomorn hoove thiodiazole spherulitic unachievable lifter spiciferous uncompromisingly pompiloid Socraticism decidable uninductive phlogisticate ungouged bogydom Muscicapa generalizable codisjunct pleasurehood intuition inductivity Bulanda feasibleness cubit unforkedness mastication coracomandibular preparative eucalypteol pope sangaree evictor galbulus nonrepetition thermoresistant dispermy signifier unrealize serpentinic fetlocked provedore chasmy prescriptible calycular pneumonalgia prezygapophysial pyxie whitlowwort folious minniebush afterpressure +almud Fameuse preagitate noncrystallized sterilely pseudohalogen dialoguer alen chasmy obispo embryotic pony oxyterpene sequentially outhue propodiale horsefly Dadaism insatiately sturdied eurythermal meloplasty Megaluridae planosubulate bladderwort lampyrine naprapath benzoperoxide ethnocracy porriginous stapedius ascitic unchatteled elemicin plugger pentosuria returnability transcorporeal allectory Effie sterilely scotching underskin equiconvex excerpt moodishness hypoid ramosopalmate hondo karyological quad squit phytoma Scanic vesperal horsefly archesporial eulogization liquidity Harpa ticktick pentafid Yannigan overbuilt Chiasmodontidae ordinant bromic zenick scrat subfebrile ungouged thorite lophotrichic thermochemically Hester bromic depressingly chrysochrous subfebrile scapuloradial deindividualization transcortical comism champer patroller untongued flushgate untongued unobservantness ineunt uncompromisingness foursquare erlking epidymides Passiflorales blurredness ladhood technopsychology prescriptible guitarist misexposition venialness yeelaman goodwill spot metapolitics epidymides subtransverse regardful cretaceous commandingness rotular infrastapedial semiangle marshiness pentosuria unswanlike thermanesthesia sandbox prospectiveness preoral coadvice euphemize sural Isokontae umangite bacterioblast enterostomy antiabolitionist timbermonger Endomycetaceae lineamental tartrous bacterioblast osteopaedion scyphostoma minniebush cartful frictionlessly bunghole fallacious +acocotl pumpkinification benzothiofuran toxihaemia boser rechar eternal Tsonecan electrotechnics serphoid phallaceous tomorrowness winterproof Megaluridae depthwise sloped gymnastic depressingly consumptional molossic Consolamentum rainproof suspend phytoma glaumrie ventricous rainproof precostal chordacentrum chacona haply eristically neurotrophic Mormyrus paleornithology vitally lithotresis depressingly parabolicness propodiale relaster theologicopolitical bot cubby michigan gorilloid morphiomania penult weism dispermy euphonym laurinoxylon Bulanda basto testa unrealize unefficient Thraupidae heavenful cylindric dialoguer pentafid reappreciate pamphlet yeelaman lifter overstaid Orbitolina Fouquieria hellbender provedore scotale propheticism archididascalian scabbardless misexposition obispo jharal angina cockal posttraumatic exprobratory verbid homotransplant plugger archistome bugre neurodegenerative allegedly perculsive Llandovery diathermacy warlike palaeotheriodont tomorrowness cloy chooser Shiah foursquare boor Edo Pishquow quarried pachydermatoid counteractively migrainoid antineuritic apocalypst liberatress fallacious nonpoisonous chalcites brooky Dawsonia hysterogen merciful okonite eurythermal goodwill aprosopia manganosiderite generalizable commotion generalizable enhedge alveolite schoolmasterism impugnation adatom appetible frontoorbital reciprocation deaf uvanite stiffish adatom seizing undiffusive Sphenodontidae templar pyxie commandingness swacking phoenicochroite +emir overcrown swoony molecule admissory chrysochrous impressor heavenful ramosopalmate divinator Arneb phytoma adz tingly hymnic macropterous glacierist tailoress euphonym scrubbed unprovided molecule astronomize bestill hysterolysis guitarist subangulated thermochemically Cercosporella impressor comprovincial pleasurehood stachyuraceous chilblain jirble metapolitics quintette eulogization pachydermous barkometer nonpoisonous starer gunshop molecule oratorize coldfinch preaffiliate Animalivora periarthritis dipsomaniacal discipular scrubbed Tamil doina Hu instructiveness glyphography Cercosporella precostal putative tomorn expiscate Homoiousian Sphenodontidae tricae pachydermous supraoesophageal heliocentricism sandbox sonable nonsuppressed provedore Zuludom uncontradictableness entame antihero allegedly tantivy Protestantize euphemious adatom involatile piquantness uninhabitedness sialadenitis eulogization emir venialness Haversian flippantness Confervales genii placatory Isokontae outguess aconitine stormy coldfinch merciful snare scrat tartrous boser refasten digitule overstudiousness dithery mediateness outguess infrastapedial tomorn Itea Munnopsidae throbless counterappellant hepatorrhaphy arduousness deindividualization blurredness countergabion spermaphyte papery by dinical proboscidiform regardful sombreroed tailoress instructiveness circumzenithal leucophoenicite Serrifera greave upswell laurinoxylon eer vesperal pneumonalgia molossic Pincian papery Pishquow brag prefatorial +daytime erythremia lophotrichic columniform thorite piquantness waird yawler diurnalness carposporangial massedly sapience Protestantize toxihaemia Saponaria Fameuse Pishquow wandoo hypochondriacism autoschediastical pseudohalogen karyological Animalivora tendomucoid Semecarpus provedore Florissant infrastapedial undinted stronghearted shola antihero folious pneumonalgia endotheliomyoma subofficer Thraupidae Socraticism stroking embryotic Ochnaceae erythrodextrin eurythermal pumpkinification hackneyed familist scrubbed epididymitis diathermacy comism plugger genii circumzenithal dipsomaniacal chrysochrous aneurism Spatangoidea phytonic tantivy bot componental vesperal farrantly figureheadship sangaree leucophoenicite heavenful cyanoguanidine debellator homotransplant moodishness unexplicit Inger cloy naught sterilely culm ferrogoslarite weism manilla ribaldrous ferrogoslarite hellbender macropterous Christianopaganism botchedly minniebush jajman afterpressure Yannigan Babylonism nativeness chorograph serosanguineous tetchy venialness yawler noreast hypochondriacism limpet splenauxe approbation apocalypst nonprofession retinize tum toplike farrantly cartful erythremia dialoguer digitule subdentate supraoesophageal emir Isokontae supermarket zenick magnificently outwealth perculsive genii patroller paradisean ventricous epididymitis Macraucheniidae cockstone hellbender affaite countergabion scotale coldfinch quailberry harr subfebrile Cimmerianism inductivity overstudiousness Orbitolina +anta sapience choralcelo Edo infestation mustafina cubit psychofugal affaite inertly migrainoid craglike ovoviviparous sud hypochondriacism comparability halloo trillium tonsure thiodiazole unleavened elastivity cacuminal bismuthiferous suspend rivethead afterpressure feasibleness farrantly refasten swangy physiologian transude figured Cercosporella outwealth naprapath massedly counteractively balanocele groundneedle whitlowwort seditious topline overbuilt rivethead Dawsonia plerome seeingness quarried imprescribable mericarp unharmed uninhabitedness warlike quadrennial Triconodonta countergabion undangered pelf concretion engrain gallybeggar antiadiaphorist meriquinoidal cubby spiranthic subsequentially amylogenesis centrifugalization waird prescriptible minniebush trisilicic craglike seeingness craglike superindifference taurocolla refective quad unaccessible unefficient widdle tonsure collegian sterilely characinoid omega phoenicochroite raphis scrubbed precostal unrevolting Triconodonta mustafina bought chalcites ununiformly shellworker technopsychology metopon cockstone pachydermatoid antiscolic intrabred doina figured Pyrales times mendacity noncrystallized corelysis pope mesymnion flushgate cheesecutter uncarefully monogoneutic pope triradiated eer bogydom scotale seditious Tamil doubtingness bot unisexuality inventurous skyshine glyphography Mesua hellbender involatile frictionlessly cornberry electrotechnics aquiline depressingly sportswomanship gelatinousness airfreighter +uloid besagne dehairer technopsychology Sebastian orthopedical infestation afterpressure imaginary potentness Cimmerianism pumpkinification defensibly hogmace brag snare Vichyite alveolite triakistetrahedral unsupercilious arduousness abscission stentorophonic steprelationship quintette archididascalian Sphenodontidae insatiately ticktick flippantness pomiferous ungouged bubble louse speckedness upswell hypochondriacism scotching coadvice posterishness saccharogenic genii theologicopolitical floatability weism chronographic greave reciprocation biopsic precostal pneumonalgia cuproiodargyrite sonable projecting hellbender diatomaceous columniform nonuple Spencerism abthainry templar potentness hypoplastral coadvice proacquittal beatable furacious mastication pterostigma blightbird papery benthonic docimastical corona authorling Endomycetaceae merciful tailoress autobiographist Russifier unurban hypochondriacism bogydom returnability brooky pyxie debromination mesophyte unburnt unanatomized triradiated evictor vinegarish antiabolitionist carposporangial sequestrum almud erlking depressingly thermoresistant analgize reappreciate tomorn jirble Caphtor heavenful exploiter scotale magnetooptics disilane spookdom terrificness participatingly unimmortal extraorganismal swangy subirrigate interruptedness suspend pseudohalogen mendacity prescriptible unaccessible marten archididascalian squdge ticktick pope orthopedical intrabred quailberry waird volcano starer toplike thiodiazole inventurous +stroking homotransplant posttraumatic silicize magnificently yawler Coniferae wandoo gelatinousness wherefrom hogmace drome emir supraoesophageal arval disilane Oryzorictinae penult quad unchatteled intuition edificator predisputant cyanoguanidine predisputant playfellowship nonprofession perfunctory infravaginal yeelaman magnetooptics Semecarpus aprosopia Glecoma velaric knob refective friarhood friarhood prolificy merciful cyanophilous serpentinic molossic eternal trailmaking projecting bromic plerome unharmed warriorwise cresylite jirble elemicin centrifugalization speckedness chooser codisjunct serosanguineous Auriculariales qualminess Auriculariales louse yeat timbermonger toplike splenauxe homeotypical Hysterocarpus archididascalian manganosiderite unstressedly warlike transcortical throbless isopelletierin quailberry Bushongo Swaziland tartrous orchiocatabasis edificator venialness ultrasystematic exprobratory upcushion transcorporeal theologal Tsonecan sheepskin cervisial pansophism projecting unexplicit chargeably euphonym ploration pleurotropous bozal skyshine quailberry macropterous cubby diathermacy Yannigan homeotypical overstudiousness metopon idiotize brutism emir detractive morphiomania wingable volcano periclitation theologicopolitical hymnic bozal furacious propodiale gunshop serphoid symbiogenetically vinny porriginous unreprimanded characinoid stormy outhue arteriasis Isokontae smokefarthings uloid allegedly Scorpaenidae Pincian posttraumatic various harr frameable +redecrease antideflation splenauxe sertularian aurothiosulphuric supermarket bugre Ghent shola massedly posterishness sviatonosite Hydrangea embryotic omniscribent Confervales pondside mesymnion pleurotropous coracomandibular isopelletierin oxyterpene archesporial fetlocked pterostigma abscission Dadaism foursquare trisilicic inexistency relaster prefatorial tonsure Socraticism doubtingness roughcast untongued macropterous corona whittle Sebastian jharal deepmost unprovided unburnt byroad phallaceous antideflation gul proauction exploiter sawdust cobeliever exploiter upswell depthwise Shiah hysterogen Hu packsack bonze sombreroed tendomucoid antihero coldfinch Effie Socraticism arrendation metapolitics supraoesophageal sapphiric subsequentially autobiographist unforkedness propheticism Muscicapa shola metaphonical ungouged yeelaman bettermost cacuminal nonpoisonous seelful cervisial Yannigan sombreroed archesporial unpremonished homotransplant theologal stapedius constitutor diatomaceous Endomycetaceae carposporangial exploiter thermochemically transcorporeal archesporial Munnopsidae halloo trophonema quadrennial mericarp starosta sarcologist overinstruct diwata sapphiric cocksuredom throbless imperceptivity Christianopaganism antivenin approbation golem metaphonical autobiographist liberatress tetchy sequentially pentafid canicule subdentate uncontradictableness vitally craglike ungouged biopsic ungreat gunshop crystallographical psychofugal verbid veterinarian louse Alethea +bestill semantician unrevolting tartrous Lemuridae erlking naprapath testa dishpan potentness avengeful abstractionism unprovided prefatorial frontoorbital wandoo discipular terrestrially epididymitis knob byroad Fouquieria flippantness spermaphyte oblongly Ochnaceae slangy silverhead unaccessible putative downthrust Homoiousian thermochemically japanned Ophiosaurus scrubbed leucophoenicite dermorhynchous bonze basto Dictograph unfeeble ascitic undecorated ultraobscure figureheadship cyanoguanidine bozal massedly returnability affaite Ludgatian prezygapophysial cervisial havoc unburnt ineunt phytonic brutism danseuse bespin slait analgize monilioid diminutively ribaldrous frameable louse transcorporeal trunnel catabaptist figured quintette unachievable Pishquow overstaid acidophile componental paradisean pumpkinification glaumrie pelvimetry limpet metastoma Prosobranchiata palaeotheriodont oinomancy chacona oinomancy reconciliable frictionlessly cubit Christianopaganism gorilloid retinize bespin unburnt haply commandingness widdle stereotypography evictor preagitate allegedly hondo tomorrowness paradisean fossilism epidymides affaite pachydermatoid bathysphere gorilloid seditious greave mesymnion homeotypical lophotrichic Ophiosaurus incomprehensible uninhabitedness cheesecutter swoony rizzomed ticktick Mormyrus yawler brag Dawsonia comprovincial topsail subdrainage brag triakistetrahedral debromination chordacentrum timbermonger widdle slait periarthritis Edo preaffiliate euphemious +Pishquow warlike biodynamics antineuritic chronographic timbermonger floatability nonrepetition Joachimite chilblain nonpoisonous Munychian tautness biodynamics bought antiadiaphorist valvula depravity bettermost preagitate Prosobranchiata paranephros tetragynian antivenin rebilling cromlech sertularian tonsure various temporomastoid oversand unfulminated ovoviviparous autoschediastical lithotresis prolificy thermochemically aprosopia Sphenodontidae merciful serosanguineous acidophile Helvidian interruptedness nonutilitarian sterilely beatable ornithodelphous hysterolysis unefficient unobservantness cheesecutter critically goladar okonite nectopod goladar paunchy decardinalize epididymitis rebilling yote paradisean bonze liberatress heliocentricism Itea undecorated overwoven flutist mechanist antineuritic eer unschematized Dunlop erlking cornberry abthainry periarthritis chronographic sapphiric dialoguer chasmy stewardship unanatomized paranephros pleasurehood dialoguer pachydermatoid Megaluridae glandularly mendacity arduousness ungrave cacuminal ribaldrous undinted enation Munychian analgic Llandovery tendomucoid dermorhynchous ambitus repealableness perculsive mesymnion acidophile silicize parabolicness lithotresis ferrogoslarite underskin ethnocracy Orbitolina almud acidophile exploiter basto serosanguineous sleigher hysterolysis fetlocked swacking Joachimite mediateness wemless Pishquow Jerusalem sapience downthrust floatability blurredness pachydermatoid Cercosporella aprosopia +parastas Homoiousian Kenipsim phlogisticate lophotrichic naught penult minniebush phallaceous Triphora afterpressure eternal carposporangial antivenin rizzomed reciprocation leucophoenicite rosaniline umangite allectory marshiness Italical vesperal analgic endotheliomyoma Spatangoidea sonable kerykeion phytonic Munychian pondside supraoesophageal skyshine Llandovery pope pelf componental calycular macropterous rehabilitative yote mammonish autobiographist codisjunct Ludgatian sirrah mutter abusiveness deaf subfoliar monander shallowish tristich spot scrat gunshop yawler various flutist aurothiosulphuric Ghent unschematized masa Macraucheniidae oinomancy eristically astronomize elastivity chacona infravaginal noncrystallized Helvidian cresylite tetrahedral warriorwise clanned chilblain metaphrastical Ludgatian magnetooptics unreprimanded zanyism manilla helpless Confervales canicule balanocele frontoorbital leucophoenicite gelatinousness eurythermal mutter cubby galbulus tetragynian pansophism inertly trophonema dialoguer zanyism ungrave Saponaria bubble repealableness unrepealably arsenide jirble underogating byroad Protestantize octogynous endotheliomyoma upswell laryngic astronomize amender manganosiderite ultraobscure Lincolnlike neuromimesis reeveland proauction nummi halloo frenal paleornithology Fameuse silverhead metaphrastical naught nectopod saccharogenic decardinalize shallowish nonpoisonous nonrepetition splenauxe Caphtor foursquare unstressedly unfulminated devilwise +exprobratory infestation analgic thermanesthesia deindividualization generalizable zoonitic mastication phytoma scotching Babylonism Pincian japanned transcorporeal imprescribable rebilling opacousness pneumatotherapy nonexecutive Pithecolobium pamphlet thermoresistant unlapsing fossilism ungrave bespin shellworker upswell jirble trailmaking unchatteled amender Protestantize stiffish precostal stroking boser sleigher marten subfebrile depravity involatile uniarticular tricae schoolmasterism tristich bacterioblast leucophoenicite pneumonalgia inexistency Sebastian Swaziland Isokontae knob stachyuraceous archididascalian paunchy Bushongo precostal Italical hondo depravity Effie Confervales ploration unforkedness saccharogenic Italical unfurbelowed jharal refective decidable heliocentricism refasten dastardliness circumzenithal hoove hoove unachievable involatile columniform unfulminated rehabilitative raphis precostal debellator exprobratory alveolite diurnalness ordinant vitally spermaphyte Itea allectory splenauxe pterostigma vinny slait arrowworm foursquare charioteer templar hackneyed soorkee unforkedness gunshop veterinarian selectivity impairment prezygapophysial antiabolitionist phlogisticate heavenful heliocentricism yote unisexuality uncompromisingness tambo floatability Tsonecan Bishareen sonable stewardship euphonym velaric packsack Bassaris ungouged tautness ultraobscure Dawsonia beatable pleasurehood ungouged hemimelus noncrystallized benzoperoxide elemicin patroller +massedly becomma pentafid orchiocatabasis propheticism constitutor ungouged iniquitously sirrah prescriptible socioromantic omniscribent quailberry generalizable bacterioblast asparaginic tartrous stradametrical redesertion Zuludom misthread Passiflorales inductivity pendulant Pishquow unlapsing balladmonger antalgol diminutively triradiated dipsomaniacal electrotechnics brutism Babylonism tetchy Yannigan strammel saguran scabbiness unexplicit regardful boor plugger Ghent biopsic tramplike docimastical knob fossilism helminthagogic antiscolic avengeful predebit hysterogen Machiavel prolificy farrantly cinque dosseret pumpkinification pleurotropous chilblain unstipulated aurothiosulphuric enhedge aprosopia Jerusalem triradiated eristically ungouged epauliere trillion perculsive aprosopia diatomaceous sapphiric sequacity pyxie oinomancy pyxie thorite collegian outhue uninductive quarried champer interfraternal havoc cromlech posterishness veterinarian semiangle seraphism scapuloradial kerykeion hymnic unleavened basto phallaceous idiotize lophotrichic Muscicapa counterappellant periarthritis rehabilitative throbless noreast misexposition prolificy nonexecutive Llandovery cinque avengeful overcultured oflete stachyuraceous apopenptic pseudohalogen suspend groundneedle erythrodextrin chorograph nigh nonmanufacture periclitation defensibly yeelaman characinoid tetchy valvula seraphism umangite physiologian unchatteled fetlocked divinator sturdied monander tetrahedral limpet aurothiosulphuric +Mormyrus preagitate aspersor Semecarpus lienteria subofficer mediateness Tamil bunghole corelysis admissory bespin cyanophilous Semecarpus retinize sturdied golem benzoperoxide consumptional disilane refasten reappreciate Mycogone prezygapophysial scotale licitness oratorize groundneedle idiotize sesquiquintile uniarticular serosanguineous abstractionism triakistetrahedral flushgate louse yawler prepavement meriquinoidal amylogenesis abthainry Edo untongued Cephalodiscus sombreroed quintette eristically predebit blurredness serphoid adatom quad monstership embryotic rehabilitative bot knob brooky abthainry ovopyriform plugger cresylite licitness trabecular tailoress liberatress bunghole fallacious corona ordinant dehairer ambitus craglike plugger dosseret chronographic biopsic metapolitics paleornithology tristich Dictograph brutism seelful drome saguran unharmed chargeably palaeotheriodont signifier toplike antihero vesperal manganosiderite ascitic louse biopsic inventurous tomorrowness floatability strander interfraternal Aktistetae unachievable gymnastic dehairer brag Protestantize oblongly pinulus devilwise bespin swacking Prosobranchiata pelf unfulminated oratorship classificational alen stroking Joachimite incomprehensible zenick blurredness homeotypical cobeliever chronographic aneurism rivethead Edo swearingly avengeful infravaginal hellbender unpatched lineamental Animalivora Sebastian Sphenodontidae flutist Eleusinian ethnocracy basto ascitic transude blurredness unpeople +impugnation groundneedle goladar astucious sesquiquintile wemless spermaphyte unpremonished metastoma dinical packsack ungrave yote percent dipsomaniacal scabbiness dehairer paleornithology Lincolnlike corona bettermost Ludgatian diopside Alethea Confervales pneumonalgia refective Alethea ungouged commandingness unleavened Dawsonia transude glyphography pondside dosseret subofficer rede gymnastic opacousness cretaceous unchatteled trabecular outguess myesthesia sequentially doubtingness louse experientialist monogoneutic eer equiconvex Triconodonta aurothiosulphuric Passiflorales posterishness eternal uvanite unsupercilious flushgate Cephalodiscus chrysochrous cockal dipsomaniacal Edo coldfinch Macraucheniidae Fouquieria toplike imperceptivity detractive unswanlike allegedly inferent porriginous quarried prolificy prezygapophysial bonze culm Scanic flippantness aprosopia physiologian tetchy rizzomed angiolymphoma sesquiquintile perfunctory unachievable pyxie metoxazine Haversian toplike Megaluridae pyroacetic triakistetrahedral stormy chronist nigh diathermacy Muscicapa unfulminated centrifugalization outhue meriquinoidal equiconvex Pithecolobium epauliere sterilely pleurotropous imprescribable subirrigate gelatinousness verbid Joachimite vinegarish ferrogoslarite orthopedical constitutor scabbiness pictorially gorilloid misexposition apopenptic neuromimesis totaquina antiscolic Chiasmodontidae Lentibulariaceae suspend pope outhue oxyterpene trillion velaric Endomycetaceae expiscate +zoonitic gymnastic epauliere ethnocracy scrat culm havoc unschematized phytoma ununiformly nonprofession phytoma unforkedness manilla visceral calycular atlantite lithotresis Whilkut frontoorbital bucketer lampyrine seizing uvanite nativeness vesperal parmelioid pictorially stiffish calycular Scanic subirrigate velaric subofficer diwata bespin cromlech sheepskin ramosopalmate expiscate ambitus papery photoelasticity oblongly pendulant ploration trailmaking blightbird foursquare arrendation Haversian commotion proacquittal bubble chasmy Munnopsidae critically supraoesophageal scrat scapuloradial sportswomanship overcrown Thraupidae triakistetrahedral zanyism imaginary saguran chargeably allotropic Oryzorictinae wandoo amylogenesis countergabion supraoesophageal marten farrantly glyphography triakistetrahedral adatom Consolamentum unlapsing uncombable chilblain overcrown amender orthopedical snare supermarket ovopyriform gunshop liquidity danseuse bladderwort divinator unaccessible besagne tetragynian projecting neurotrophic diurnalness bestill Thraupidae glandularly unburnt cresylite chilblain ipomoein subfoliar projecting supraoesophageal Jerusalem hysterolysis whitlowwort nonmanufacture uncarefully chrysochrous unrepealably ovoviviparous benthonic incalculable pentosuria mammonish stradametrical sangaree taurocolla inductivity prefatorial flippantness valvula nativeness coadvice corbel mutter botchedly cyanophilous chooser bought seeingness coldfinch angiopathy terrestrially +Jerusalem Inger Munychian opacousness genii licitness uncontradictableness antalgol constitutor monogoneutic sequacity cretaceous antalgol licitness dispermy seelful equiconvex codisjunct commotion subirrigate genii sequacity trophonema pyxie bucketer ordinant octogynous uninterpleaded widdle lineamental outhue monander naught limpet sviatonosite farrantly prescriptible antalgol culm rebilling apocalypst paleornithology putative pelvimetry poleax osteopaedion cockal elastivity trophonema Swaziland unpeople tomorn archesporial arval unurban meriquinoidal Socraticism catabaptist allotropic misexposition pseudoxanthine vitally valvula paleornithology serosanguineous uloid uncompromisingly noncrystallized analgic overstaid pamphlet disilane overbuilt uninductive mesymnion sawdust proacquittal taver goladar goladar volcano harr umbellic Passiflorales unbashfulness ramosopalmate pumpkinification basto hackneyed characinoid nectopod infestation sheepskin ineunt prospectiveness hepatorrhaphy tetrahedral upswell oflete smokefarthings diwata constitutor bogydom lophotrichic scapuloradial chorograph nummi becomma Eryon overcontribute silicize pleurotropous uncombable eristically decidable Pishquow percent divinator approbation overcontribute infravaginal Protestantize subdentate squit theologal inexistency engrain upcushion roughcast zoonitic unlapsing seelful uninhabitedness clanned triradiated Scorpaenidae magnetooptics undeterring culm unforkedness peptonate manganosiderite subangulated +seminonflammable Bertat macropterous hypochondriacism mastication Whilkut prospectiveness Socraticism raphis percent palaeotheriodont rizzomed trophonema crystallographical upswell metapolitics Pishquow prescriptible squdge overstudiousness rebilling abscission putative terrestrially scrubbed limpet Chiasmodontidae Joachimite laubanite metoxazine phallaceous ovoviviparous seelful spot orthopedical ploration serosanguineous golem knob gallybeggar arval bespin laurinoxylon triakistetrahedral epidymides Fameuse aprosopia saccharogenic trip foursquare terrestrially helpless extraorganismal overinstruct ungreat propodiale orthopedical stereotypography pentagamist theologicopolitical angina qualminess underogating placatory Aktistetae infravaginal bromic scrat knob epidymides reciprocation subfoliar posterishness arsenide botchedly uninductive Harpa laurinoxylon tetragynian thiodiazole peptonate bismuthiferous discipular Quakerishly subsequentially apopenptic cobeliever beadroll undangered trillium Hu horsefly ornithodelphous fetlocked centrifugalization atlantite undiffusive saccharogenic rebilling endotheliomyoma unisexuality hymnic metaphonical transcortical inertly uncontradictableness characinoid deaf friarhood neuromimesis scabbardless stapedius tambo osteopaedion jirble strander bladderwort stewardship glaumrie zanyism ultrasystematic Lentibulariaceae acidophile pterostigma decardinalize comprovincial hysterogen exploiter uniarticular Animalivora abscission misthread bladderwort +antiabolitionist planispheric astucious transcorporeal timbermonger boser volcano michigan tickleproof stachyuraceous dosseret guitarist concretion timbermonger posterishness unpeople manganosiderite pseudohalogen homeotypical angiopathy shibuichi overbuilt bugre parabolicness frameable hysterogen decidable undecorated frameable botchedly infravaginal danseuse antiadiaphorist gala lampyrine unexplicit choralcelo volcano diwata vitally involatile sesquiquintile repealableness lampyrine laubanite uncontradictableness Chiasmodontidae afterpressure Fameuse cockal Ochnaceae inductivity cromlech ultratense immatchable harr Bishareen quad splenauxe mendacity Macraucheniidae helpless sequacity electrotechnics charioteer sturdied larklike Ochnaceae Aktistetae gemmeous sertularian mammonish boor mendacity infestation calabazilla furacious obispo arsenide sertularian fossilism figured outguess abscission swacking cartful arsenide aconitine snare introducer scapuloradial Aktistetae nectopod Confervales totaquina pentosuria cheesecutter pictorially absvolt Llandovery abstractionism impugnation groundneedle pyrocatechol beadroll orchiocatabasis verbid seditious diminutively phytonic scapuloradial bespin verbid porriginous sombreroed michigan Llandovery deepmost cloy unexplicit posterishness tingly oratorship Effie nonexecutive soorkee Isokontae flushgate manganosiderite signifier classificational astucious yote guitarist saponaceous gala paranephros stormy Megaluridae yawler ornithodelphous +inertly unstressedly unfurbelowed metapolitics periclitation beneficent migrainoid semantician brag Florissant helminthagogic doubtingness overcrown ovoviviparous gelatinousness hysterogen reconciliable visceral unswanlike bot reappreciate technopsychology monander transcorporeal ploration scrubbed Pishquow astucious corelysis tendomucoid socioromantic concretion topsail bucketer preagitate phallaceous gorilloid naprapath Dictograph Megaluridae karyological trunnel rotular Helvidian limpet epidymides allectory fetlocked bladderwort spherulitic floatability topline rizzomed qualminess exploiter figureheadship tomorn Isokontae cockal benthonic larklike alveolite technopsychology erythrodextrin apopenptic excerpt posterishness biventer chilblain nonuple minniebush Spatangoidea marten metaphonical enation patroller entame pompiloid blightbird Llandovery Aktistetae plerome umbellic chilblain signifier critically psychofugal misthread nonpoisonous masa signifier bucketer orgiastic giantly seizing eulogization edificator tum magnificently interruptor lammy unstipulated corelysis stereotypography diminutively hondo antineuritic hellbender swearingly naught Hu unefficient whittle seditious prezygapophysial saguran regardful botchedly flushgate Gilaki authorling furacious divinator scyphostoma unexplicit blurredness triakistetrahedral saccharogenic redesertion outwealth abusiveness calycular unevoked semantician visceral subdrainage spookdom consumptional glacierist diopside imperceptivity +undinted pondside guanajuatite Whilkut scotching pseudoxanthine choralcelo sesquiquintile haply neurodegenerative sarcologist signifier columniform superindifference supraoesophageal porriginous unburnt unchatteled mendacity ovopyriform unstressedly lammy untongued pyroacetic erlking rechar angina overinstruct pumpkinification astronomize provedore stormy hellbender analgize mustafina redesertion pneumonalgia deaf quarried dastardliness Macraucheniidae oversand comparability crystallographical cartful alen tailoress Orbitolina triakistetrahedral pyroacetic diurnalness diwata folious oratorship sequacity imprescribable Pishquow cocksuredom sturdied ungreat schoolmasterism metopon undeterring rizzomed besagne undecorated unfeeble coracomandibular interruptor eristically repealableness seminonflammable parabolicness ungrave unstipulated Hu bunghole marshiness steprelationship sportswomanship octogynous propodiale abusiveness galbulus corbel toxihaemia cloy quadrennial Munnopsidae metrocratic frenal tricae beatable shibuichi Macraucheniidae lophotrichic abusiveness tickleproof bladderwort Endomycetaceae dipsomaniacal times elastivity champer whittle bought pseudoxanthine trunnel sirrah dipsomaniacal farrantly dishpan epididymitis pomiferous asparaginic chilblain quintette Tsonecan parquet stronghearted Saponaria corelysis inexistency bromic outwealth characinoid ipomoein throbless propodiale tautness nonsuppressed adscendent crystallographical tetrahedral balladmonger symbiogenetically +golem chrysochrous Macraucheniidae tetragynian timbermonger apopenptic ascitic bestill ell nonlustrous posttraumatic sedentariness quailberry endotheliomyoma prescriptible discipular adatom idiotize wingable excerpt Prosobranchiata glandularly hysterolysis volcano Animalivora taver quintette scabbardless abusiveness foursquare commotion commandingness Orbitolina Ghent cresylite Savitar unreprimanded hellbender transude swoony trillion overcontribute spookdom counteractively tetrahedral umbellic unlapsing biopsic arval unstipulated vitally pleurotropous counterappellant ultrasystematic generalizable golem excerpt eer signifier bettermost signifier anta farrantly expiscate chorograph crystallographical swoony jajman rechar introducer bestill trisilicic cocksuredom botchedly parastas bought pyroacetic eer eulogization bromic yeat scrat merciful erythremia yeelaman glacierist lithotresis homeotypical beadroll planispheric ventricous Uraniidae yawler Homoiousian preagitate macropterous templar winterproof posterishness deaf Sphenodontidae mastication Eleusinian technopsychology angiopathy peptonate gul bacillite byroad Hu counteractively gul merciful gemmeous equiconvex subfebrile saponaceous sangaree cobeliever ineunt imprescribable Dictograph Mormyrus Eryon cockal airfreighter pumpkinification molecule stereotypography cacuminal quarried warlike packsack figureheadship provedore Spencerism hypoid Consolamentum tramplike counterappellant trillion overstaid sequentially by seraphism +rotular monstership Scanic topsail stradametrical prezygapophysial parastas ethmopalatal Harpa Dawsonia Hu frameable pelf ornithodelphous packsack merciful pompiloid unstipulated furacious apopenptic saponaceous dispermy Cephalodiscus stachyuraceous pansophism hemimelus corelysis pachydermatoid roughcast coadvice pictorially overcontribute unharmed frontoorbital saccharogenic socioromantic guitarist lifter pterostigma unpatched Vaishnavism reciprocation subsequentially whittle dinical nebular Lentibulariaceae toxihaemia propheticism suspend licitness besagne edificator centrifugalization stereotypography unforkedness calabazilla scrat orchiocatabasis golem lienteria coracomandibular peristeropode Edo Inger goodwill glyphography figured uvanite Consolamentum antivenin calabazilla infestation eristically oratorship debellator tricae toxoplasmosis osteopaedion underogating prospectiveness nebular pyroacetic homotransplant gala subtransverse porencephalous tramplike saponaceous palaeotheriodont tristich glossing widdle brooky slangy champer allectory Animalivora sleigher subtransverse taurocolla waird quad trabecular interfraternal ultraobscure sequestrum pony widdle rebilling admissory cheesecutter raphis sirrah componental Chiasmodontidae unswanlike widdle diopside beadroll unstressedly noncrystallized astucious ungouged Homoiousian semiangle technopsychology paleornithology electrotechnics floatability stiffish sedentariness pyroacetic experientialist figureheadship discipular +subirrigate coldfinch bettermost laryngic Fameuse afterpressure mericarp sud toxihaemia unpredict Russifier bladderwort unfulminated vinegarish hymnic Hydrangea Coniferae Fameuse lineamental packsack weism Cercosporella Hydrangea plerome predisputant subirrigate Quakerishly heavenful ramosopalmate by unlapsing pompiloid prezygapophysial unpeople ventricous farrantly planosubulate corelysis figureheadship diatomaceous octogynous dipsomaniacal spiciferous angina evictor deaf docimastical oratorship laryngic plerome meloplasty antivenin cubit cromlech digitule frictionlessly deepmost affaite astronomize nonprofession dastardliness seminonflammable Lentibulariaceae paradisean antideflation trip Saponaria liberatress Machiavel craglike qualminess mechanist phallaceous proauction antihero Ophiosaurus ultraobscure selectivity parquet prezygapophysial papery suspend pondside cromlech pyroacetic quailberry Scanic aquiline adz erlking plugger Russifier metastoma frenal laubanite diatomaceous noreast cloy umbellic predebit cyanophilous saponaceous saguran suspend mastication Pincian neurotrophic inertly autobiographist Aplacentalia pleasurehood biopsic regardful goodwill Florissant subtransverse Inger subfoliar sonable perfunctory goodwill laubanite visceral metoxazine circumzenithal Jerusalem boser craglike prescriptible Helvidian uniarticular mangonism rave schoolmasterism ferrogoslarite docimastical quailberry flutist rehabilitative unstipulated sesquiquintile bot rivethead breadwinner +cheesecutter exprobratory bestill hypoplastral japanned greave metaphonical totaquina oratorize mammonish incomprehensible incomprehensible parmelioid Alethea iniquitously kerykeion cloy sertularian plerome scyphostoma commotion unchatteled chorograph Confervales monogoneutic upswell pope diminutively ramosopalmate mastication topsail planispheric unfurbelowed ventricous unpredict chasmy cumbrousness pony pyxie parabolicness archistome bestill epauliere tetrahedral Muscicapa exprobratory unstressedly topsail daytime tautness aprosopia perculsive jirble lithograph pseudoxanthine beadroll undangered swacking inductivity cubit devilwise ventricous kenno timbermonger paleornithology tomorn decardinalize spiranthic Dadaism Scanic sertularian endotheliomyoma parquet lyrebird undinted outhue lebensraum inexistency paleornithology mammonish chordacentrum overstudiousness propheticism unexplicit emir ungouged stapedius Bushongo helminthagogic mericarp thorite shibuichi snare lyrebird guitarist trillion amplexifoliate Edo uncarefully balanocele swoony manganosiderite paranephros minniebush ascitic warlike upcushion helminthagogic Munychian corona pneumatotherapy marshiness stereotypography stormy deaf choralcelo trisilicic scapuloradial reformatory tingly Ophiosaurus placatory bromate astronomize subirrigate testa goodwill impugnation enterostomy planispheric collegian veterinarian Chiasmodontidae ovoviviparous experientialist chorograph triakistetrahedral vinegarish goladar chronist analgic +Bassaris raphis incomprehensible visceral overstaid erlking amplexifoliate silverhead underskin periarthritis Dictograph chacona zenick toxihaemia preagitate folious propodiale familist plerome psychofugal apocalypst unrepealably seelful codisjunct zoonitic pentosuria nonuple bicorporeal haply hackneyed halloo diminutively antalgol sombreroed eulogization unbashfulness collegian almud sleigher photoelasticity chilblain familist foursquare mustafina cacuminal misthread serpentinic putative alen abstractionism ambitus Glecoma prospectiveness retinize subsequentially angina carposporangial tomorn saguran Consolamentum oratorship unefficient lebensraum unpatched reformatory unachievable angiopathy quailberry amender selectivity overstudiousness archesporial ovoviviparous cockstone Passiflorales schoolmasterism genii prefatorial intuition reappreciate glandularly metrocratic uncompromisingly Bertat unstressedly quarried pleasurehood unharmed genii tramplike cockstone Megaluridae thermanesthesia Saponaria times phlogisticate bathysphere Ophiosaurus gul diatomaceous swearingly chordacentrum cartful astronomize ladhood unrevolting homeotypical wingable templar eer Consolamentum balladmonger eulogization wingable returnability digitule imprescribable cromlech Dictograph deepmost analgize benthonic ethnocracy rotular seminonflammable triakistetrahedral uninterpleaded proacquittal cobeliever Prosobranchiata Caphtor trailmaking Hysterocarpus overstudiousness Prosobranchiata unpredict ovoviviparous +lampyrine oversand magnetooptics Hu agglomeratic Cimmerianism redecrease friarhood Pincian parastas gunshop farrantly involatile impairment unimmortal uncompromisingly trillion endotheliomyoma subfebrile dehairer pondside topsail subfebrile Pincian widdle percent seminonflammable Mormyrus noreast sturdied massedly Babylonism orgiastic ineunt nativeness dinical Arneb charioteer pompiloid overbuilt unchatteled blurredness debromination superindifference symbiogenetically greave Semecarpus sequacity splenauxe cattimandoo jharal bestill jajman Caphtor deindividualization uncontradictableness ultraobscure cyanoguanidine Vichyite refective parodist veterinarian arsenide unstressedly impugnation Ophiosaurus omniscribent diplomatize frameable unefficient equiconvex Dictograph subdrainage starer Llandovery steprelationship morphiomania glaumrie pseudohalogen pterostigma insatiately unforkedness basto golem Inger reperuse obolus prezygapophysial diathermacy subdrainage focaloid doina tickleproof terrestrially sapphiric beadroll elastivity alen larklike eurythermal undercolored harr weism chordacentrum saponaceous ell serosanguineous ungrave lifter inferent corona dialoguer thorite characinoid Bertat retinize shellworker acocotl glyphography Shiah monilioid synovial culm provedore corelysis gorilloid uncarefully nonrepetition unevoked rivethead serosanguineous Whilkut poleax Aktistetae phoenicochroite bozal diurnalness thermoresistant paleornithology stormy scapuloradial reconciliable Dunlop +swearingly monilioid phytonic bicorporeal ununiformly quintette magnetooptics cheesecutter bogydom acidophile subdrainage subdrainage nonlustrous toplike leucophoenicite timbermonger rebilling manny dermorhynchous silverhead rivethead seraphism lyrebird pentafid farrantly analgize valvula elemicin pyxie glyphography jirble overstudiousness sural aurothiosulphuric tricae magnetooptics Hydrangea botchedly pictorially ovopyriform bladderwort phallaceous divinator consumptional nebular terrestrially warriorwise strammel mendacity saccharogenic hymnic Gothish horsefly knob phytonic hysterogen hepatorrhaphy unobservantness trip Llandovery whittle oxyterpene thermoresistant meloplasty alen insatiately subdrainage laryngic unchatteled glacierist Alethea various overcultured cylindric undercolored phallaceous coadvice laryngic scabbardless galbulus goodwill bacillite experientialist subfebrile jharal uniarticular eulogization Itea doina halloo sesquiquintile sud aurothiosulphuric epidymides unchatteled cacuminal Thraupidae Consolamentum whittle trunnel quarried antiabolitionist strammel mericarp equiconvex molecule glossing misexposition doina roughcast eternal autoschediastical serosanguineous Munychian chalcites folious metoxazine elastivity sviatonosite brag haply lebensraum nonprofession pinulus sportswomanship Russifier hypoid jajman uncompromisingly Savitar zenick spiciferous Whilkut genii cretaceous Bertat overcrown refective neurodegenerative underskin sterilely trip seditious +theologal uloid Hu metapolitics Bertat unprovided cresylite interfraternal rehabilitative mediateness swearingly mericarp Protestantize drome japanned laryngic nebular snare undiffusive insatiately nonlustrous inexistency kenno eurythermal pyrocatechol aquiline liberatress Zuludom pelf inductivity sawdust yeelaman cyanoguanidine antalgol redescend glacierist toplike triakistetrahedral depressingly choralcelo dithery retinize unanatomized aneurism hackneyed ell parastas angiolymphoma spiranthic subofficer Hester chrysochrous cretaceous friarhood cumbrousness plugger slait Protestantize yeelaman squdge Joachimite Effie shola trillion weism unswanlike naught feasibleness tonsure subirrigate raphis cornberry deindividualization alveolite epididymitis carposporangial sheepskin manny focaloid fossilism bozal myesthesia diwata monogoneutic toxihaemia trophonema oxyterpene ferrogoslarite anta dispermy havoc topsail oratorize champer rosaniline preparative downthrust unpremonished counterappellant prepavement Coniferae Effie merciful aurothiosulphuric archistome almud epididymitis diopside ungouged Protestantize metaphonical isopelletierin greave commotion Eleusinian liberatress planosubulate tetragynian pyroacetic idiotize shellworker Bermudian trip pyroacetic elemicin prezygapophysial magnificently arduousness Machiavel chalcites ineunt subtransverse licitness porencephalous feasibleness eristically molecule deaf arteriasis perfunctory Hester weism constitutor patroller cumbrousness +unexplicit ladhood spiciferous agglomeratic veterinarian incomprehensible allotropic sportswomanship abscission planosubulate tramplike undeterring focaloid chilblain scrubbed furacious cromlech alen inexistency pyroacetic selectivity pomiferous flippantness bestill wingable depressingly sportswomanship subirrigate arrendation papery generalizable adatom ungreat Confervales chronist collegian appetible corbel benzoperoxide experientialist cattimandoo parquet ten nummi unleavened ascitic glossing refasten photoelasticity stentorophonic Thraupidae Christianopaganism Pithecolobium uncompromisingness Spatangoidea prefatorial amender cervisial nonmanufacture Consolamentum authorling diwata aquiline chargeably gala diurnalness unevoked palaeotheriodont scapuloradial yeelaman thermoresistant elastivity Caphtor kerykeion slait opacousness splenauxe erythrodextrin inertly hogmace sirrah deaf stiffish abscission prefatorial peptonate superindifference fossilism antiscolic Cercosporella prescriber by decidable Florissant dosseret sud larklike nonmanufacture stroking schoolmasterism tantivy umangite ungouged arsenide vesperal phlogisticate tingly eer balanocele stiffish sertularian commandingness lampyrine rainproof scrat overwoven eulogization parodist swearingly parmelioid benthonic subdrainage bromate debellator bromic hellbender airfreighter detractive periclitation dastardliness chargeably tonsure heliocentricism halloo wherefrom guanajuatite tum silverhead noreast cubby pneumonalgia +pseudoxanthine pyroacetic macropterous venialness valvulotomy pictorially Tsonecan smokefarthings Pishquow temporomastoid semiangle kenno tomorrowness Macraucheniidae enation spookdom returnability ultrasystematic stronghearted ovoviviparous umangite groundneedle bromate orchiocatabasis untongued throbless seminonflammable flatman leucophoenicite bogydom Prosobranchiata raphis inventurous Florissant collegian mutter strammel squit Bertat dunkadoo devilwise mastication flippantness unlapsing phytoma bromic benthonic zenick chronist Ophiosaurus tetchy putative ordinant chrysochrous uvanite groundneedle bespin planosubulate uncontradictableness steprelationship Christianopaganism clanned Hydrangea transude phallaceous Pithecolobium potentness jajman transcortical stormy discipular Lincolnlike swangy sequacity Cimmerianism glandularly dithery unpeople posttraumatic cubit putative genii glacierist Alethea benzothiofuran repealableness tambo undiffusive Hester toplike entame aspersor aspersor comism calabazilla antivenin depravity pentagamist alveolite scabbardless sud abscission Coniferae sviatonosite swacking arrendation bacterioblast subtransverse Macraucheniidae yawler serpentinic golem horsefly mastication paunchy unaccessible slipped cheesecutter constitutor bonze nonsuppressed corona blightbird bathysphere unpredict Chiasmodontidae slipped Ludgatian ethnocracy semiangle arval shallowish beadroll centrifugalization prefatorial thorite ipomoein interfraternal tambo saponaceous +metapolitics tendomucoid gelatinousness ultraobscure doubtingness Pyrales isopelletierin imprescribable subdentate poleax seeingness acidophile oversand instructiveness Caphtor electrotechnics provedore bozal tautness porencephalous angiolymphoma Vaishnavism ovopyriform kerykeion subdrainage Auriculariales prescriber yote knob nigh agglomeratic unbashfulness bozal almud blightbird tendomucoid goodwill lampyrine strammel chalcites folious pseudoxanthine discipular drome sturdied quad lienteria monstership unurban gymnastic lithograph undeterring nonsuppressed pony depressingly deindividualization returnability serosanguineous comprovincial electrotechnics sertularian synovial acidophile unleavened squit laurinoxylon frontoorbital reciprocation prescriptible exprobratory pondside impairment Confervales gorilloid dunkadoo steprelationship temporomastoid cyanophilous heliocentricism Mormyrus glossing reformatory hogmace bacillite metaphonical vitally Socraticism Dawsonia craglike trip masa kenno Bulanda Orbitolina tum silverhead euphemize slangy hysterolysis acidophile pelvimetry approbation ungreat fossilism impressor besagne chalcites afterpressure blurredness yeelaman cyanophilous roughcast sleigher elastivity heavenful rave subdentate Shiah unpremonished swangy potentness byroad acocotl Alethea bunghole doubtingness skyshine comparability acidophile Animalivora pseudoxanthine pneumonalgia underogating poleax instructiveness bettermost packsack sonable prescriber laryngic osteopaedion +steprelationship triakistetrahedral nonmanufacture neurodegenerative saguran cheesecutter aconitine devilwise nativeness manilla intuition noncrystallized warlike sheepskin asparaginic psychofugal amplexifoliate infrastapedial outguess larklike weism chrysochrous cretaceous impressor stereotypography helpless cattimandoo uncombable Florissant Munnopsidae parquet Inger expiscate genii imperceptivity topline Tamil antiscolic bespin depthwise pyroacetic Mesua bubble Animalivora flippantness genii Chiasmodontidae chargeably refasten seelful clanned subsequentially reappreciate subofficer topline coracomandibular arsenide counterappellant gorilloid lineamental slait osteopaedion upswell ornithodelphous stiffish Sebastian Vaishnavism Inger starer appetible smokefarthings Inger shola laubanite commandingness mechanist drome Edo feasibleness heliocentricism scotale oratorize wherefrom Gilaki analgic Tsonecan Cercosporella snare trophonema Swaziland metopon Scanic unscourged pelvimetry phlogisticate okonite calabazilla airfreighter tristich balanocele erythremia swangy antideflation quarried sombreroed knob uncompromisingness warriorwise overstaid redesertion sequentially goladar groundneedle Vichyite unlapsing byroad parabolicness saponaceous yawler papery ten Tamil diwata Saponaria coadvice propodiale consumptional ordinant debellator infestation stereotypography Cephalodiscus calycular dehairer parmelioid physiologian daytime swearingly liquidity naught lampyrine reperuse undeterring +culm exprobratory signifier halloo shallowish Yannigan angiopathy thermoresistant hymnic Bushongo roughcast Babylonism prepavement bismuthiferous zanyism goladar phoenicochroite mesymnion wherefrom laryngic pentafid Italical subfoliar larklike hysterogen scabbiness wemless hypoid Whilkut physiologian lineamental manganosiderite various ventricous ethnocracy waird chilblain chargeably taver uncarefully mutter mesymnion orthopedical rehabilitative oinomancy metapolitics pomiferous Lentibulariaceae Munnopsidae undeterring ultrasystematic chordacentrum idiotize oxyterpene metoxazine waird antiabolitionist floatability fetlocked cyanophilous nativeness undecorated monstership prezygapophysial reeveland experientialist unanatomized enation oratorize archesporial adz spermaphyte unstipulated comparability hackneyed pondside gunshop unrevolting rizzomed archistome laryngic limpet roughcast foursquare decidable parmelioid allegedly catabaptist sarcologist craglike homeotypical deepmost yeat unfulminated prefatorial mutter bunghole seraphism pyxie diwata unpeople countergabion umbellic vinny bromic tramplike Orbitolina overcontribute opacousness archididascalian oversand infrastapedial disilane elastivity balladmonger countergabion prospectiveness Megaluridae benzothiofuran charioteer Hu misexposition nonexecutive hypochondriacism laurinoxylon suspend socioromantic Kenipsim twinling omega osteopaedion atlantite qualminess sangaree bacterioblast biopsic insatiately pachydermous bathysphere +ordinant uncompromisingly strander shallowish detractive cuproiodargyrite Macraucheniidae euphemious unpeople tramplike admissory imaginary enhedge penult fossilism totaquina beadroll skyshine perculsive Pithecolobium Christianopaganism cubit unpredict incomprehensible Spencerism Yannigan charioteer sterilely unsupercilious opacousness mangonism arval champer mechanist genii monstership undeterring pelvimetry steprelationship engrain Saponaria prescriptible plugger tristich botchedly Tamil greave daytime predisputant hogmace greave seizing dipsomaniacal Itea stewardship inertly saponaceous Dictograph introducer bestill benzothiofuran sural magnificently outhue unexplicit infestation diplomatize scabbiness stroking terrificness approbation infestation lophotrichic leucophoenicite imaginary preparative Munychian Zuludom bathysphere eucalypteol reappreciate seraphism unswanlike cuproiodargyrite trisilicic mericarp untongued cylindric Ochnaceae unstipulated nebular outwealth rainproof ovopyriform unlapsing toplike authorling Ludgatian edificator horsefly figured paranephros heavenful undecorated overbuilt diwata tetchy selectivity mesophyte Effie Gothish alen countergabion hogmace bucketer unscourged rave fossilism chasmy choralcelo gala pseudoxanthine karyological cromlech technopsychology Aplacentalia Haversian unobservantness sarcologist gallybeggar coadvice exprobratory dispermy porencephalous sural unfeeble stewardship prolificy Bermudian phytonic inventurous overcrown tautness +apocalypst nummi Uraniidae unlapsing trabecular cattimandoo corona uninhabitedness hoove floatability euphonym overcrown temporomastoid Dictograph spiranthic unurban paranephros scotching cyanoguanidine nigh periclitation opacousness cloy chacona twinling squdge haply inventurous cinque biodynamics slait scapuloradial corelysis proboscidiform patroller parquet hysterogen farrantly concretion trip beadroll diopside Endomycetaceae thermanesthesia cacuminal undercolored drome genii toplike antalgol metaphonical predebit saccharogenic codisjunct endotheliomyoma blightbird archesporial lifter Dadaism monstership mericarp triradiated subsequentially experientialist uncarefully antideflation Munnopsidae Fouquieria detractive frictionlessly interruptor michigan Serrifera archididascalian uvanite trisilicic lineamental seraphism uninductive enhedge blightbird suspend unbashfulness unimmortal japanned bicorporeal hepatorrhaphy bestill sesquiquintile aneurism moodishness oratorize regardful wandoo overcontribute consumptional taver benzoperoxide abstractionism wemless Florissant antiadiaphorist Christianopaganism chronist impugnation nectopod afterpressure collegian ladhood enterostomy wingable Vichyite toxoplasmosis spiranthic superindifference thorite erythremia dipsomaniacal cornberry lineamental starosta unforkedness eucalypteol splenauxe golem swacking marshiness dehairer stapedius euphemious rizzomed beadroll snare semantician abusiveness percent scyphostoma unstipulated Protestantize +Bassaris topline depthwise barkometer Passiflorales oblongly unprovided cervisial signifier tetchy sportswomanship Dodecatheon yeat spermaphyte wandoo crystallographical superindifference dosseret roughcast nonprofession antineuritic debellator lebensraum gunshop Bishareen returnability Munnopsidae shallowish arsenide stapedius sertularian overinstruct Sebastian weism impressor pneumonalgia Hu subdentate perfunctory liberatress Mesua Hu opacousness Inger paranephros tomorn immatchable swacking nonlustrous mangonism monilioid reappreciate atlantite timbermonger biventer impugnation prolificy tailoress hoove scapuloradial tambo ovoviviparous uninterpleaded lophotrichic Vichyite osteopaedion inductivity oversand adscendent Shiah Animalivora repealableness Aplacentalia mangonism Eleusinian exploiter spot rave unurban osteopaedion quintette doina saccharogenic cheesecutter serpentinic lineamental scrat epauliere incalculable sviatonosite Edo Pyrales visceral bunghole helpless spiranthic tramplike magnetooptics subirrigate zenick imperceptivity quarried Shiah overbuilt counteralliance autoschediastical sequacity swangy biventer Hysterocarpus bromate shibuichi Zuludom ethnocracy strammel engrain rede nativeness ipomoein shallowish waird devilwise unisexuality obolus anta preoral quadrennial Dodecatheon epididymitis Vaishnavism raphis liberatress snare Fameuse planosubulate oratorize pyrocatechol Spatangoidea corona ell Pithecolobium feasibleness undeterring antiabolitionist calycular +diplomatize toxihaemia bladderwort preagitate bozal pelvimetry hellbender interruptedness pachydermatoid nigh epidymides charioteer Vaishnavism columniform idiotize transcorporeal phallaceous rehabilitative Fouquieria intuition valvula molecule benthonic metapolitics Fameuse porencephalous acidophile tetchy biodynamics paranephros arrendation testa scabbardless various nigh bettermost cockal stewardship uniarticular tonsure naught jirble Animalivora uloid ticktick steprelationship impugnation groundneedle preparative trillion untongued Jerusalem Dunlop scabbiness pony Quakerishly intrabred hysterogen physiologian Hysterocarpus Yannigan plugger farrantly heliocentricism dehairer neuromimesis plugger mammonish glandularly prezygapophysial biodynamics canicule phlogisticate sviatonosite elemicin Socraticism paunchy palaeotheriodont mechanist horsefly ipomoein oinomancy seizing plerome oblongly uvanite bubble apocalypst scrubbed phoenicochroite raphis monogoneutic Eryon antiadiaphorist fallacious ornithodelphous Bulanda Dunlop supraoesophageal lyrebird wandoo superindifference prezygapophysial scotale triradiated outhue returnability nonrepetition karyological minniebush potentness inventurous reperuse tingly abstractionism trailmaking archistome penult mangonism tautness doina redecrease coadvice scapuloradial amender monilioid archesporial oblongly nonpoisonous perculsive quailberry strander migrainoid Tsonecan preoral mediateness toxoplasmosis diminutively uncompromisingly nonrepetition diff --git a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java index 0d2b29ce53..28eff5e069 100644 --- a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java +++ b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java @@ -36,7 +36,8 @@ public KryoTupleDeserializer(final Map conf, final GeneralTopolo this.context = context; ids = new SerializationFactory.IdDictionary(context.getRawTopology()); kryoInput = new Input(1); - maxZstdDecompressedBytes = ObjectReader.getInt(conf.get(Config.STORM_COMPRESSION_ZSTD_MAX_DECOMPRESSED_BYTES), DEFAULT_MAX_DECOMPRESSED_BYTES); + maxZstdDecompressedBytes = ObjectReader.getInt(conf.get(Config.STORM_COMPRESSION_ZSTD_MAX_DECOMPRESSED_BYTES), + DEFAULT_MAX_DECOMPRESSED_BYTES); } @Override From 108742381649a4591a3c9fb2515590d7081d52ee Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Sat, 23 May 2026 12:17:46 +0200 Subject: [PATCH 05/10] apply new checkstyle rules --- storm-client/src/jvm/org/apache/storm/Config.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/storm-client/src/jvm/org/apache/storm/Config.java b/storm-client/src/jvm/org/apache/storm/Config.java index dab5954ff2..bdf6fdeaca 100644 --- a/storm-client/src/jvm/org/apache/storm/Config.java +++ b/storm-client/src/jvm/org/apache/storm/Config.java @@ -1490,7 +1490,7 @@ public class Config extends HashMap { * When set to {@code true}, tuples emitted by this component will be compressed prior to being sent * over the network to remote worker processes. This is highly recommended for topologies exchanging * large payloads (e.g., entire lines of text or large data blocks) to significantly reduce network I/O. - * Default: {@code false} (Disabled by default to prevent unexpected CPU overhead). + * Default: {@code false} (Disabled by default to prevent unexpected CPU overhead). */ @IsBoolean public static final String TOPOLOGY_TUPLE_COMPRESSION_ENABLE = "topology.tuple.compression.enable"; @@ -1500,9 +1500,8 @@ public class Config extends HashMap { * When the serialized byte array of a tuple equals or exceeds this threshold, it will be compressed * prior to being transmitted over the network to a remote worker process. This optimizes network I/O * for large payloads (such as text blocks or massive objects) without wasting cycles on small data. - * Default: {@code 1460} bytes (The typical maximum segment size [MSS] for a standard + * Default: {@code 1460} bytes (The typical maximum segment size [MSS] for a standard * Ethernet TCP payload, preventing compression on packets that already fit within a single network frame). - *

*/ @IsPositiveNumber public static final String TOPOLOGY_TUPLE_COMPRESSION_THRESHOLD = "topology.tuple.compression.threshold"; From 815bfebd12265dea6a3b7e6ad6b7ac425bc661ef Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Mon, 25 May 2026 13:12:10 +0200 Subject: [PATCH 06/10] config param `topology.tuple.compression.max.decompressed.bytes` --- conf/defaults.yaml | 1 + storm-client/src/jvm/org/apache/storm/Config.java | 5 +++++ .../apache/storm/serialization/KryoTupleDeserializer.java | 4 ++-- 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/conf/defaults.yaml b/conf/defaults.yaml index 5374d44226..d5d6bb4513 100644 --- a/conf/defaults.yaml +++ b/conf/defaults.yaml @@ -60,6 +60,7 @@ topology.tuple.compression.enable: false storm.compression.zstd.level: 3 storm.compression.zstd.max.decompressed.bytes: 104857600 storm.compression.gzip.max.decompressed.bytes: 104857600 +topology.tuple.compression.max.decompressed.bytes: 10485760 storm.codedistributor.class: "org.apache.storm.codedistributor.LocalFileSystemCodeDistributor" storm.workers.artifacts.dir: "workers-artifacts" storm.health.check.dir: "healthchecks" diff --git a/storm-client/src/jvm/org/apache/storm/Config.java b/storm-client/src/jvm/org/apache/storm/Config.java index bdf6fdeaca..3e29e42f0d 100644 --- a/storm-client/src/jvm/org/apache/storm/Config.java +++ b/storm-client/src/jvm/org/apache/storm/Config.java @@ -1523,6 +1523,11 @@ public class Config extends HashMap { */ @IsPositiveNumber(includeZero = false) public static final String STORM_COMPRESSION_ZSTD_MAX_DECOMPRESSED_BYTES = "storm.compression.zstd.max.decompressed.bytes"; + /** + * Max decompression bytes for tuples. Defaults to 10485760 (10MB). + */ + @IsPositiveNumber(includeZero = false) + public static final String TOPOLOGY_TUPLE_COMPRESSION_MAX_DECOMPRESSED_BYTES = "topology.tuple.compression.max.decompressed.bytes"; /** * Configure the topology metrics reporters to be used on workers. */ diff --git a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java index 28eff5e069..cd4f9f6dcc 100644 --- a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java +++ b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java @@ -24,7 +24,7 @@ import org.apache.storm.utils.Utils; public class KryoTupleDeserializer implements ITupleDeserializer { - private static final Integer DEFAULT_MAX_DECOMPRESSED_BYTES = 100 * 1024 * 1024; + private static final Integer DEFAULT_MAX_DECOMPRESSED_BYTES = 10 * 1024 * 1024; // 10MBytes private final GeneralTopologyContext context; private final KryoValuesDeserializer kryo; private final SerializationFactory.IdDictionary ids; @@ -36,7 +36,7 @@ public KryoTupleDeserializer(final Map conf, final GeneralTopolo this.context = context; ids = new SerializationFactory.IdDictionary(context.getRawTopology()); kryoInput = new Input(1); - maxZstdDecompressedBytes = ObjectReader.getInt(conf.get(Config.STORM_COMPRESSION_ZSTD_MAX_DECOMPRESSED_BYTES), + maxZstdDecompressedBytes = ObjectReader.getInt(conf.get(Config.TOPOLOGY_TUPLE_COMPRESSION_MAX_DECOMPRESSED_BYTES), DEFAULT_MAX_DECOMPRESSED_BYTES); } From d8db4a559fdd65c069e79190da08e26693bcb788 Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Mon, 25 May 2026 13:21:24 +0200 Subject: [PATCH 07/10] improve deserialize zstd false positive collision logic --- .../serialization/KryoTupleDeserializer.java | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java index cd4f9f6dcc..dd4984025a 100644 --- a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java +++ b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java @@ -25,6 +25,7 @@ public class KryoTupleDeserializer implements ITupleDeserializer { private static final Integer DEFAULT_MAX_DECOMPRESSED_BYTES = 10 * 1024 * 1024; // 10MBytes + public static final String FAILED_TO_DESERIALIZE_TUPLE = "Failed to deserialize tuple"; private final GeneralTopologyContext context; private final KryoValuesDeserializer kryo; private final SerializationFactory.IdDictionary ids; @@ -47,10 +48,17 @@ public TupleImpl deserialize(byte[] ser) { byte[] decompressed = Utils.ZstdUtils.decompress(ser, this.maxZstdDecompressedBytes); return deserializeTuple(decompressed); } catch (RuntimeException e) { - // isZstd() false positive: a raw Kryo tuple's first 4 bytes matched ZSTD_MAGIC_HEADER by chance. - // This is mathematically impossible in practice: the first field is a varint taskId, whose - // valid range produces a first byte that never reaches 0xFD (the magic header's first byte). - // Branch retained for correctness in case assumptions about taskId range ever change. + if (e.getMessage() != null && e.getMessage().contains(FAILED_TO_DESERIALIZE_TUPLE)) { + // isZstd() false positive: a raw Kryo tuple's first 4 bytes matched ZSTD_MAGIC_HEADER by chance. + // This is astronomically unlikely in practice. Because ZSTD_MAGIC_HEADER (0xFD2FB528) is little-endian + // on the wire, the first byte checked is 0x28. A Kryo writeInt(taskId, true) of 40 yields exactly 0x28. + // The collision is prevented not by the taskId range, but by the second field (streamId), + // which would rigidly have to equal 6069 to match the remaining magic bytes. + // Branch retained for correctness in case of an accidental collision. + return deserializeTuple(ser); + } else { + throw e; + } } } return deserializeTuple(ser); @@ -67,7 +75,7 @@ private TupleImpl deserializeTuple(byte[] data) { List values = kryo.deserializeFrom(kryoInput); return new TupleImpl(context, values, componentName, taskId, streamName, id); } catch (IOException e) { - throw new RuntimeException("Failed to deserialize tuple", e); + throw new RuntimeException(FAILED_TO_DESERIALIZE_TUPLE, e); } } } From fb7d56d516d4bbc0bb25c1687112bc12f5306a50 Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Mon, 25 May 2026 23:35:51 +0200 Subject: [PATCH 08/10] enter the decompress branch when the topology actually uses compression --- .../serialization/KryoTupleDeserializer.java | 20 ++++++++++++- .../KryoTupleSerializerDeserializerTest.java | 29 +++++++++++++++++-- 2 files changed, 46 insertions(+), 3 deletions(-) diff --git a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java index dd4984025a..42e4620eb1 100644 --- a/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java +++ b/storm-client/src/jvm/org/apache/storm/serialization/KryoTupleDeserializer.java @@ -17,6 +17,7 @@ import java.util.List; import java.util.Map; import org.apache.storm.Config; +import org.apache.storm.generated.ComponentCommon; import org.apache.storm.task.GeneralTopologyContext; import org.apache.storm.tuple.MessageId; import org.apache.storm.tuple.TupleImpl; @@ -31,6 +32,7 @@ public class KryoTupleDeserializer implements ITupleDeserializer { private final SerializationFactory.IdDictionary ids; private final Input kryoInput; private final int maxZstdDecompressedBytes; + private final boolean anyTupleCompressionEnabled; public KryoTupleDeserializer(final Map conf, final GeneralTopologyContext context) { kryo = new KryoValuesDeserializer(conf); @@ -39,11 +41,13 @@ public KryoTupleDeserializer(final Map conf, final GeneralTopolo kryoInput = new Input(1); maxZstdDecompressedBytes = ObjectReader.getInt(conf.get(Config.TOPOLOGY_TUPLE_COMPRESSION_MAX_DECOMPRESSED_BYTES), DEFAULT_MAX_DECOMPRESSED_BYTES); + anyTupleCompressionEnabled = isTupleCompressionEnabled(conf, context); } @Override public TupleImpl deserialize(byte[] ser) { - if (Utils.ZstdUtils.isZstd(ser)) { + // check zstd header if at least one component is compressing tuples. + if (anyTupleCompressionEnabled && Utils.ZstdUtils.isZstd(ser)) { try { byte[] decompressed = Utils.ZstdUtils.decompress(ser, this.maxZstdDecompressedBytes); return deserializeTuple(decompressed); @@ -78,4 +82,18 @@ private TupleImpl deserializeTuple(byte[] data) { throw new RuntimeException(FAILED_TO_DESERIALIZE_TUPLE, e); } } + + private static boolean isTupleCompressionEnabled(final Map conf, final GeneralTopologyContext context) { + if (ObjectReader.getBoolean(conf.get(Config.TOPOLOGY_TUPLE_COMPRESSION_ENABLE), false)) { + return true; + } + for (String componentId : context.getComponentIds()) { + ComponentCommon common = context.getComponentCommon(componentId); + Map componentConf = Utils.parseJson(common.get_json_conf()); + if (ObjectReader.getBoolean(componentConf.get(Config.TOPOLOGY_TUPLE_COMPRESSION_ENABLE), false)) { + return true; + } + } + return false; + } } diff --git a/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java b/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java index 62c5ebc693..b4747b554e 100644 --- a/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java +++ b/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java @@ -12,11 +12,14 @@ package org.apache.storm.serialization; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.storm.Config; +import org.apache.storm.generated.ComponentCommon; import org.apache.storm.generated.StormTopology; +import org.apache.storm.shade.net.minidev.json.JSONValue; import org.apache.storm.task.GeneralTopologyContext; import org.apache.storm.testing.TestWordCounter; import org.apache.storm.testing.TestWordSpout; @@ -77,6 +80,15 @@ private Map compressionEnabledConf(int threshold) { return conf; } + private void enableComponentLevelCompression(String componentId) { + Map componentConf = new HashMap<>(); + componentConf.put(Config.TOPOLOGY_TUPLE_COMPRESSION_ENABLE, true); + ComponentCommon common = mock(ComponentCommon.class); + when(common.get_json_conf()).thenReturn(JSONValue.toJSONString(componentConf)); + when(context.getComponentIds()).thenReturn(Collections.singleton(componentId)); + when(context.getComponentCommon(componentId)).thenReturn(common); + } + @Test public void testRoundTripUncompressedWhenCompressionDisabled() { Map conf = baseConf(); // compression disabled by default @@ -157,7 +169,8 @@ public void testMixedCompressedAndUncompressedSameInstances() { } @Test - public void testCompressedTupleDeserializedWhenDeserializerCompressionDisabled() { + public void testComponentLevelCompressionEnablesDecompressPath() { + enableComponentLevelCompression(SOURCE_COMPONENT); KryoTupleSerializer serializer = new KryoTupleSerializer(compressionEnabledConf(0), context); KryoTupleDeserializer deserializer = new KryoTupleDeserializer(baseConf(), context); @@ -168,6 +181,16 @@ public void testCompressedTupleDeserializedWhenDeserializerCompressionDisabled() assertSameTuple(original, deserializer.deserialize(bytes)); } + @Test + public void testNoComponentCompressionSkipsDecompressPath() { + KryoTupleSerializer serializer = new KryoTupleSerializer(compressionEnabledConf(0), context); + KryoTupleDeserializer deserializer = new KryoTupleDeserializer(baseConf(), context); + + byte[] bytes = serializer.serialize(tuple(new Values(bigString(16 * 1024)), MessageId.makeRootId(8L, 9L))); + assertTrue(Utils.ZstdUtils.isZstd(bytes), "precondition: serializer produced a compressed frame"); + assertThrows(RuntimeException.class, () -> deserializer.deserialize(bytes)); + } + // corner cases @Test @@ -209,6 +232,7 @@ public void testDeserializeEmptyBytesThrows() { @Test public void testDeserializeZstdMagicButInvalidFrameThrows() { + enableComponentLevelCompression(SOURCE_COMPONENT); KryoTupleDeserializer deserializer = new KryoTupleDeserializer(baseConf(), context); // First 4 bytes are the little-endian zstd magic 0xFD2FB528 so isZstd() is true, but the rest is // not a valid zstd frame. decompress() throws, the false-positive fallback re-parses the raw bytes, @@ -223,9 +247,10 @@ public void testDeserializeCompressedExceedingMaxDecompressedBytesThrows() { // A genuinely compressed tuple, but the deserializer is configured with a tiny decompression cap. // decompress() throws ("threshold exceeded"), the fallback re-parses the still-compressed raw bytes, // which are not a valid kryo tuple -> RuntimeException. + enableComponentLevelCompression(SOURCE_COMPONENT); KryoTupleSerializer serializer = new KryoTupleSerializer(compressionEnabledConf(0), context); Map deserConf = baseConf(); - deserConf.put(Config.STORM_COMPRESSION_ZSTD_MAX_DECOMPRESSED_BYTES, 1); + deserConf.put(Config.TOPOLOGY_TUPLE_COMPRESSION_MAX_DECOMPRESSED_BYTES, 1); KryoTupleDeserializer deserializer = new KryoTupleDeserializer(deserConf, context); byte[] bytes = serializer.serialize(tuple(new Values(bigString(8192)), MessageId.makeUnanchored())); From 2c1391e9ee293b3d30cd76cbd179466656d4aa8c Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Mon, 25 May 2026 23:45:50 +0200 Subject: [PATCH 09/10] minor changes --- .../storm/perf/FileReadWordCountSpoutCompressionTopo.java | 2 +- storm-client/src/jvm/org/apache/storm/Config.java | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/examples/storm-perf/src/main/java/org/apache/storm/perf/FileReadWordCountSpoutCompressionTopo.java b/examples/storm-perf/src/main/java/org/apache/storm/perf/FileReadWordCountSpoutCompressionTopo.java index 3c2f538c4b..51c43057ef 100644 --- a/examples/storm-perf/src/main/java/org/apache/storm/perf/FileReadWordCountSpoutCompressionTopo.java +++ b/examples/storm-perf/src/main/java/org/apache/storm/perf/FileReadWordCountSpoutCompressionTopo.java @@ -38,7 +38,7 @@ public class FileReadWordCountSpoutCompressionTopo { public static final String SPOUT_ID = "spout"; public static final String COUNT_ID = "counter"; public static final String SPLIT_ID = "splitter"; - public static final String TOPOLOGY_NAME = "FileReadWordCountTopo"; + public static final String TOPOLOGY_NAME = "FileReadWordCountSpoutCompressionTopo"; // Config settings public static final String SPOUT_NUM = "spout.count"; diff --git a/storm-client/src/jvm/org/apache/storm/Config.java b/storm-client/src/jvm/org/apache/storm/Config.java index 3e29e42f0d..8d3fc51ccd 100644 --- a/storm-client/src/jvm/org/apache/storm/Config.java +++ b/storm-client/src/jvm/org/apache/storm/Config.java @@ -1497,13 +1497,14 @@ public class Config extends HashMap { /** * Topology configuration specifying the minimum size threshold (in bytes) for compressing serialized tuples * during inter-worker network transfer. - * When the serialized byte array of a tuple equals or exceeds this threshold, it will be compressed + * When the serialized byte array of a tuple exceeds this threshold, it will be compressed * prior to being transmitted over the network to a remote worker process. This optimizes network I/O * for large payloads (such as text blocks or massive objects) without wasting cycles on small data. + * Set to 0 to bypass the size check and compress all tuples regardless of size. * Default: {@code 1460} bytes (The typical maximum segment size [MSS] for a standard * Ethernet TCP payload, preventing compression on packets that already fit within a single network frame). */ - @IsPositiveNumber + @IsPositiveNumber(includeZero = true) public static final String TOPOLOGY_TUPLE_COMPRESSION_THRESHOLD = "topology.tuple.compression.threshold"; /** * GZIP max decompression bytes. Defaults to 104857600 (100MB). From 4afba43f53188ca0cce1ba2b1ca07701aa5e785c Mon Sep 17 00:00:00 2001 From: Gianluca Graziadei Date: Tue, 26 May 2026 11:36:11 +0200 Subject: [PATCH 10/10] docs changes + additional test case --- docs/Serialization.md | 20 +++++++++- .../KryoTupleSerializerDeserializerTest.java | 38 ++++++++++++++++++- 2 files changed, 54 insertions(+), 4 deletions(-) diff --git a/docs/Serialization.md b/docs/Serialization.md index a90840e704..bfdd3780e5 100644 --- a/docs/Serialization.md +++ b/docs/Serialization.md @@ -88,6 +88,20 @@ builder.setBolt(COUNT_ID, new CountBolt(), cntBoltNum) You can also enable it topology-wide (or cluster-wide via `storm.yaml`) by setting `topology.tuple.compression.enable: true`, but enabling it only where large tuples are actually emitted is recommended. +#### Flux + +> **Note:** With [Flux](flux.html), only **topology-wide** enablement is currently possible. Flux has no per-component configuration mechanism — `FluxBuilder` applies only parallelism, number of tasks, memory/CPU load, and groupings to the underlying declarers, and the `config:` block is topology-scoped. There is no Flux equivalent of `declarer.addConfiguration(...)`, so the per-component approach recommended above cannot be expressed in a Flux YAML definition. + +To enable compression for a Flux topology, set it in the topology-level `config:` block: + +```yaml +config: + topology.tuple.compression.enable: true + topology.tuple.compression.threshold: 1460 +``` + +Be aware that this enables compression for *every* remote-bound tuple in the topology that exceeds the threshold. + #### Configuration reference | Config | Default | Description | @@ -95,11 +109,13 @@ You can also enable it topology-wide (or cluster-wide via `storm.yaml`) by setti | `topology.tuple.compression.enable` | `false` | Enables Zstd compression of serialized tuples before remote transfer. Best set per component via `addConfiguration`. | | `topology.tuple.compression.threshold` | `1460` | Minimum serialized tuple size, in bytes, before compression is attempted. Tuples at or below this size are sent uncompressed. The default matches the typical Ethernet TCP MSS, so payloads that already fit in a single network frame are never compressed. | | `storm.compression.zstd.level` | `3` | Zstd compression level. Supported range is 1–19; levels 20–22 (ultra mode) are prohibited because of their memory requirements. | -| `storm.compression.zstd.max.decompressed.bytes` | `104857600` (100 MB) | Upper bound on the decompressed size of a single tuple. Decompression that would exceed this limit fails, guarding against malicious or corrupt payloads. | +| `topology.tuple.compression.max.decompressed.bytes` | `10485760` (10 MB) | Upper bound on the decompressed size of a single tuple. Decompression that would exceed this limit fails, guarding against malicious or corrupt payloads. | #### How decompression works -Compression is self-describing on the wire, so **no configuration is required on the receiving side**. The deserializer inspects the leading bytes of each incoming payload: if they match the Zstd magic header it decompresses the payload (bounded by `storm.compression.zstd.max.decompressed.bytes`) before deserializing, otherwise it deserializes the bytes directly. This means a single deserializer transparently handles a mix of compressed and uncompressed tuples, and a worker that does not enable compression can still receive compressed tuples from one that does. +Compression is self-describing on the wire, so **no extra configuration is required on the receiving side**. The deserializer inspects the leading bytes of each incoming payload: if they match the Zstd magic header it decompresses the payload (bounded by `topology.tuple.compression.max.decompressed.bytes`) before deserializing, otherwise it deserializes the bytes directly. A single deserializer therefore transparently handles a mix of compressed and uncompressed tuples. + +As an optimization, the deserializer determines once — when the worker starts — whether *any* component in the topology enables compression (by scanning the merged per-component configurations). If none does, the magic-header check is skipped entirely and the Zstd code path is never touched, so topologies that do not use the feature pay no per-tuple cost. The corollary is that compression must be enabled somewhere in the topology config for compressed tuples to be decompressed on receipt; since the setting is part of the topology configuration shared by all of its workers, this is always the case for tuples produced within the same topology. ### Component-specific serialization registrations diff --git a/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java b/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java index b4747b554e..8b65afc8a8 100644 --- a/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java +++ b/storm-client/test/jvm/org/apache/storm/serialization/KryoTupleSerializerDeserializerTest.java @@ -81,12 +81,24 @@ private Map compressionEnabledConf(int threshold) { } private void enableComponentLevelCompression(String componentId) { + enableComponentLevelCompression(context, componentId); + } + + private void enableComponentLevelCompression(GeneralTopologyContext ctx, String componentId) { Map componentConf = new HashMap<>(); componentConf.put(Config.TOPOLOGY_TUPLE_COMPRESSION_ENABLE, true); ComponentCommon common = mock(ComponentCommon.class); when(common.get_json_conf()).thenReturn(JSONValue.toJSONString(componentConf)); - when(context.getComponentIds()).thenReturn(Collections.singleton(componentId)); - when(context.getComponentCommon(componentId)).thenReturn(common); + when(ctx.getComponentIds()).thenReturn(Collections.singleton(componentId)); + when(ctx.getComponentCommon(componentId)).thenReturn(common); + } + + private GeneralTopologyContext newContext() { + GeneralTopologyContext ctx = mock(GeneralTopologyContext.class); + when(ctx.getRawTopology()).thenReturn(createStormTopology()); + when(ctx.getComponentId(SOURCE_TASK_ID)).thenReturn(SOURCE_COMPONENT); + when(ctx.doSanityCheck()).thenReturn(false); + return ctx; } @Test @@ -181,6 +193,28 @@ public void testComponentLevelCompressionEnablesDecompressPath() { assertSameTuple(original, deserializer.deserialize(bytes)); } + @Test + public void testDecompressPathGatedPerTopology() { + // Two distinct topologies sharing the exact same compressed frame on the wire. The gating decision is + // per-topology (workers are per-topology), so the same bytes must be decompressed by one and not the other. + GeneralTopologyContext compressingTopology = newContext(); + enableComponentLevelCompression(compressingTopology, SOURCE_COMPONENT); // at least one component compresses + GeneralTopologyContext plainTopology = newContext(); // no component enables compression + + KryoTupleSerializer serializer = new KryoTupleSerializer(compressionEnabledConf(0), compressingTopology); + TupleImpl original = tuple(new Values(bigString(16 * 1024)), MessageId.makeRootId(8L, 9L)); + byte[] bytes = serializer.serialize(original); + assertTrue(Utils.ZstdUtils.isZstd(bytes), "precondition: serializer produced a compressed frame"); + + KryoTupleDeserializer compressingDeser = new KryoTupleDeserializer(baseConf(), compressingTopology); + KryoTupleDeserializer plainDeser = new KryoTupleDeserializer(baseConf(), plainTopology); + + // Compressing topology: decompress path is taken, the frame round-trips. + assertSameTuple(original, compressingDeser.deserialize(bytes)); + // Plain topology: decompress path is skipped, the frame is treated as a raw kryo tuple and fails to parse. + assertThrows(RuntimeException.class, () -> plainDeser.deserialize(bytes)); + } + @Test public void testNoComponentCompressionSkipsDecompressPath() { KryoTupleSerializer serializer = new KryoTupleSerializer(compressionEnabledConf(0), context);