@Override public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility( TypeSerializer<T> newSerializer) { // in prior versions, the compatibility check was in the serializer itself, so we // delegate this call to the serializer. final CompatibilityResult<T> compatibility = newSerializer.ensureCompatibility(this); return compatibility.isRequiresMigration() ? TypeSerializerSchemaCompatibility.incompatible() : TypeSerializerSchemaCompatibility.compatibleAsIs(); } }
newSerializer); if (!initialResult.isRequiresMigration()) { return initialResult; } else {
/** * This cannot be removed until {@link TypeSerializerConfigSnapshot} is no longer supported. */ @Override public CompatibilityResult<Lockable<E>> ensureCompatibility(TypeSerializerConfigSnapshot<?> configSnapshot) { // backwards compatibility path CompatibilityResult<E> inputCompatibilityResult = CompatibilityUtil.resolveCompatibilityResult( configSnapshot.restoreSerializer(), UnloadableDummyTypeSerializer.class, configSnapshot, elementSerializer); return (inputCompatibilityResult.isRequiresMigration()) ? CompatibilityResult.requiresMigration() : CompatibilityResult.compatible(); }
namespaceSerializer); if (keySerializerCompatibility.isRequiresMigration() || namespaceSerializerCompatibility.isRequiresMigration()) { throw new IllegalStateException("Tried to initialize restored TimerService " + "with incompatible serializers than those used to snapshot its state.");
@SuppressWarnings("unchecked") private CompatibilityResult<T> ensureFieldCompatibility( List<Tuple2<TypeSerializer<?>, TypeSerializerConfigSnapshot>> previousSerializersAndConfigs) { TypeSerializer<Object>[] convertSerializers = new TypeSerializer[fieldSerializers.length]; boolean requiresMigration = false; for (int index = 0; index < previousSerializersAndConfigs.size(); index++) { CompatibilityResult<Object> compatResult = resolveFieldCompatibility(previousSerializersAndConfigs, index); if (compatResult.isRequiresMigration()) { requiresMigration = true; if (compatResult.getConvertDeserializer() != null) { convertSerializers[index] = new TypeDeserializerAdapter<>(compatResult.getConvertDeserializer()); } else { return CompatibilityResult.requiresMigration(); } } } return requiresMigration ? createMigrationCompatResult(convertSerializers) : CompatibilityResult.compatible(); }
versionSerializer); if (!keyCompatResult.isRequiresMigration() && !valueCompatResult.isRequiresMigration() && !versionCompatResult.isRequiresMigration()) { return CompatibilityResult.compatible(); } else {
fieldSerializers[fieldIndex]); if (compatResult.isRequiresMigration()) { requiresMigration = true; reorderedRegisteredSubclassSerializers[i]); if (compatResult.isRequiresMigration()) { requiresMigration = true; cachedSerializer); if (compatResult.isRequiresMigration()) { requiresMigration = true;
sharedBufferSerializer); if (!sharedBufCompatResult.isRequiresMigration() && !eventCompatResult.isRequiresMigration()) { return CompatibilityResult.compatible(); } else {
fieldSerializers[i]); if (compatResult.isRequiresMigration()) { requiresMigration = true;
@Test public void testSerializeReconfiguredEnumSerializer() throws Exception { // mock the previous ordering of enum constants to be BAR, PAULA, NATHANIEL PublicEnum[] mockPreviousOrder = {PublicEnum.BAR, PublicEnum.PAULA, PublicEnum.NATHANIEL}; // now, the actual order of FOO, BAR, PETER, NATHANIEL, EMMA, PAULA will be the "new wrong order" EnumSerializer<PublicEnum> serializer = new EnumSerializer<>(PublicEnum.class); // verify that the serializer is first using the "wrong order" (i.e., the initial new configuration) assertEquals(PublicEnum.FOO.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.FOO).intValue()); assertEquals(PublicEnum.BAR.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.BAR).intValue()); assertEquals(PublicEnum.PETER.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PETER).intValue()); assertEquals(PublicEnum.NATHANIEL.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.NATHANIEL).intValue()); assertEquals(PublicEnum.EMMA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.EMMA).intValue()); assertEquals(PublicEnum.PAULA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PAULA).intValue()); // reconfigure and verify compatibility CompatibilityResult<PublicEnum> compatResult = serializer.ensureCompatibility( new EnumSerializer.EnumSerializerConfigSnapshot<>(PublicEnum.class, mockPreviousOrder)); assertFalse(compatResult.isRequiresMigration()); // serialize and deserialize again the serializer byte[] serializedSerializer = InstantiationUtil.serializeObject(serializer); serializer = InstantiationUtil.deserializeObject(serializedSerializer, Thread.currentThread().getContextClassLoader()); // verify that after the serializer was read, the reconfigured constant ordering is untouched PublicEnum[] expectedOrder = {PublicEnum.BAR, PublicEnum.PAULA, PublicEnum.NATHANIEL, PublicEnum.FOO, PublicEnum.PETER, PublicEnum.EMMA}; int i = 0; for (PublicEnum constant : expectedOrder) { assertEquals(i, serializer.getValueToOrdinal().get(constant).intValue()); i++; } assertTrue(Arrays.equals(expectedOrder, serializer.getValues())); }
@Test public void testReconfiguration() { // mock the previous ordering of enum constants to be BAR, PAULA, NATHANIEL PublicEnum[] mockPreviousOrder = {PublicEnum.BAR, PublicEnum.PAULA, PublicEnum.NATHANIEL}; // now, the actual order of FOO, BAR, PETER, NATHANIEL, EMMA, PAULA will be the "new wrong order" EnumSerializer<PublicEnum> serializer = new EnumSerializer<>(PublicEnum.class); // verify that the serializer is first using the "wrong order" (i.e., the initial new configuration) assertEquals(PublicEnum.FOO.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.FOO).intValue()); assertEquals(PublicEnum.BAR.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.BAR).intValue()); assertEquals(PublicEnum.PETER.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PETER).intValue()); assertEquals(PublicEnum.NATHANIEL.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.NATHANIEL).intValue()); assertEquals(PublicEnum.EMMA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.EMMA).intValue()); assertEquals(PublicEnum.PAULA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PAULA).intValue()); // reconfigure and verify compatibility CompatibilityResult<PublicEnum> compatResult = serializer.ensureCompatibility( new EnumSerializer.EnumSerializerConfigSnapshot<>(PublicEnum.class, mockPreviousOrder)); assertFalse(compatResult.isRequiresMigration()); // after reconfiguration, the order should be first the original BAR, PAULA, NATHANIEL, // followed by the "new enum constants" FOO, PETER, EMMA PublicEnum[] expectedOrder = {PublicEnum.BAR, PublicEnum.PAULA, PublicEnum.NATHANIEL, PublicEnum.FOO, PublicEnum.PETER, PublicEnum.EMMA}; int i = 0; for (PublicEnum constant : expectedOrder) { assertEquals(i, serializer.getValueToOrdinal().get(constant).intValue()); i++; } assertTrue(Arrays.equals(expectedOrder, serializer.getValues())); }
@Override public TypeSerializerSchemaCompatibility<T> resolveSchemaCompatibility( TypeSerializer<T> newSerializer) { // in prior versions, the compatibility check was in the serializer itself, so we // delegate this call to the serializer. final CompatibilityResult<T> compatibility = newSerializer.ensureCompatibility(this); return compatibility.isRequiresMigration() ? TypeSerializerSchemaCompatibility.incompatible() : TypeSerializerSchemaCompatibility.compatibleAsIs(); } }
/** * This cannot be removed until {@link TypeSerializerConfigSnapshot} is no longer supported. */ @Override public CompatibilityResult<Lockable<E>> ensureCompatibility(TypeSerializerConfigSnapshot<?> configSnapshot) { // backwards compatibility path CompatibilityResult<E> inputCompatibilityResult = CompatibilityUtil.resolveCompatibilityResult( configSnapshot.restoreSerializer(), UnloadableDummyTypeSerializer.class, configSnapshot, elementSerializer); return (inputCompatibilityResult.isRequiresMigration()) ? CompatibilityResult.requiresMigration() : CompatibilityResult.compatible(); }
/** * This cannot be removed until {@link TypeSerializerConfigSnapshot} is no longer supported. */ @Override public CompatibilityResult<Lockable<E>> ensureCompatibility(TypeSerializerConfigSnapshot<?> configSnapshot) { // backwards compatibility path CompatibilityResult<E> inputCompatibilityResult = CompatibilityUtil.resolveCompatibilityResult( configSnapshot.restoreSerializer(), UnloadableDummyTypeSerializer.class, configSnapshot, elementSerializer); return (inputCompatibilityResult.isRequiresMigration()) ? CompatibilityResult.requiresMigration() : CompatibilityResult.compatible(); }
@SuppressWarnings("unchecked") private CompatibilityResult<T> ensureFieldCompatibility( List<Tuple2<TypeSerializer<?>, TypeSerializerConfigSnapshot>> previousSerializersAndConfigs) { TypeSerializer<Object>[] convertSerializers = new TypeSerializer[fieldSerializers.length]; boolean requiresMigration = false; for (int index = 0; index < previousSerializersAndConfigs.size(); index++) { CompatibilityResult<Object> compatResult = resolveFieldCompatibility(previousSerializersAndConfigs, index); if (compatResult.isRequiresMigration()) { requiresMigration = true; if (compatResult.getConvertDeserializer() != null) { convertSerializers[index] = new TypeDeserializerAdapter<>(compatResult.getConvertDeserializer()); } else { return CompatibilityResult.requiresMigration(); } } } return requiresMigration ? createMigrationCompatResult(convertSerializers) : CompatibilityResult.compatible(); }
@Override public CompatibilityResult<T> ensureCompatibility(TypeSerializerConfigSnapshot configSnapshot) { if (configSnapshot instanceof NullableSerializerConfigSnapshot) { List<Tuple2<TypeSerializer<?>, TypeSerializerConfigSnapshot>> previousKvSerializersAndConfigs = ((NullableSerializerConfigSnapshot) configSnapshot).getNestedSerializersAndConfigs(); CompatibilityResult<T> compatResult = CompatibilityUtil.resolveCompatibilityResult( previousKvSerializersAndConfigs.get(0).f0, UnloadableDummyTypeSerializer.class, previousKvSerializersAndConfigs.get(0).f1, originalSerializer); if (!compatResult.isRequiresMigration()) { return CompatibilityResult.compatible(); } else if (compatResult.getConvertDeserializer() != null) { return CompatibilityResult.requiresMigration( new NullableSerializer<>( new TypeDeserializerAdapter<>(compatResult.getConvertDeserializer()), padNullValue())); } } return CompatibilityResult.requiresMigration(); }
@Override public CompatibilityResult<StreamRecord<T>> ensureCompatibility(TypeSerializerConfigSnapshot configSnapshot) { if (configSnapshot instanceof StreamRecordSerializerConfigSnapshot) { Tuple2<TypeSerializer<?>, TypeSerializerConfigSnapshot> previousTypeSerializerAndConfig = ((StreamRecordSerializerConfigSnapshot) configSnapshot).getSingleNestedSerializerAndConfig(); CompatibilityResult<T> compatResult = CompatibilityUtil.resolveCompatibilityResult( previousTypeSerializerAndConfig.f0, UnloadableDummyTypeSerializer.class, previousTypeSerializerAndConfig.f1, typeSerializer); if (!compatResult.isRequiresMigration()) { return CompatibilityResult.compatible(); } else if (compatResult.getConvertDeserializer() != null) { return CompatibilityResult.requiresMigration( new StreamRecordSerializer<>( new TypeDeserializerAdapter<>(compatResult.getConvertDeserializer()))); } } return CompatibilityResult.requiresMigration(); }
@Override public CompatibilityResult<ArrayList<T>> ensureCompatibility(TypeSerializerConfigSnapshot configSnapshot) { if (configSnapshot instanceof CollectionSerializerConfigSnapshot) { Tuple2<TypeSerializer<?>, TypeSerializerConfigSnapshot> previousElemSerializerAndConfig = ((CollectionSerializerConfigSnapshot) configSnapshot).getSingleNestedSerializerAndConfig(); CompatibilityResult<T> compatResult = CompatibilityUtil.resolveCompatibilityResult( previousElemSerializerAndConfig.f0, UnloadableDummyTypeSerializer.class, previousElemSerializerAndConfig.f1, elementSerializer); if (!compatResult.isRequiresMigration()) { return CompatibilityResult.compatible(); } else if (compatResult.getConvertDeserializer() != null) { return CompatibilityResult.requiresMigration( new ArrayListSerializer<>(new TypeDeserializerAdapter<>(compatResult.getConvertDeserializer()))); } } return CompatibilityResult.requiresMigration(); } }
@Override public CompatibilityResult<StreamElement> ensureCompatibility(TypeSerializerConfigSnapshot configSnapshot) { if (configSnapshot instanceof MultiplexingStreamRecordSerializerConfigSnapshot) { Tuple2<TypeSerializer<?>, TypeSerializerConfigSnapshot> previousTypeSerializerAndConfig = ((MultiplexingStreamRecordSerializerConfigSnapshot) configSnapshot).getSingleNestedSerializerAndConfig(); CompatibilityResult<T> compatResult = CompatibilityUtil.resolveCompatibilityResult( previousTypeSerializerAndConfig.f0, UnloadableDummyTypeSerializer.class, previousTypeSerializerAndConfig.f1, typeSerializer); if (!compatResult.isRequiresMigration()) { return CompatibilityResult.compatible(); } else if (compatResult.getConvertDeserializer() != null) { return CompatibilityResult.requiresMigration( new MultiplexingStreamRecordSerializer<>( new TypeDeserializerAdapter<>(compatResult.getConvertDeserializer()))); } } return CompatibilityResult.requiresMigration(); }
@Override public CompatibilityResult<List<T>> ensureCompatibility(TypeSerializerConfigSnapshot configSnapshot) { if (configSnapshot instanceof CollectionSerializerConfigSnapshot) { Tuple2<TypeSerializer<?>, TypeSerializerConfigSnapshot> previousElemSerializerAndConfig = ((CollectionSerializerConfigSnapshot) configSnapshot).getSingleNestedSerializerAndConfig(); CompatibilityResult<T> compatResult = CompatibilityUtil.resolveCompatibilityResult( previousElemSerializerAndConfig.f0, UnloadableDummyTypeSerializer.class, previousElemSerializerAndConfig.f1, elementSerializer); if (!compatResult.isRequiresMigration()) { return CompatibilityResult.compatible(); } else if (compatResult.getConvertDeserializer() != null) { return CompatibilityResult.requiresMigration( new ListSerializer<>(new TypeDeserializerAdapter<>(compatResult.getConvertDeserializer()))); } } return CompatibilityResult.requiresMigration(); } }