import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
-import java.io.DataInput;
import java.io.IOException;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.controller.cluster.raft.persisted.LegacySerializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Robert Varga
*/
-public sealed class AbortTransactionPayload extends AbstractIdentifiablePayload<TransactionIdentifier> {
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Magnesium extends AbortTransactionPayload implements LegacySerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- Magnesium(final TransactionIdentifier transactionId, final byte[] serialized) {
- super(transactionId, serialized);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy extends AbstractProxy<TransactionIdentifier> {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- protected TransactionIdentifier readIdentifier(final DataInput in) throws IOException {
- return TransactionIdentifier.readFrom(in);
- }
-
- @Override
- protected AbortTransactionPayload createObject(final TransactionIdentifier identifier,
- final byte[] serialized) {
- return new Magnesium(identifier, serialized);
- }
- }
-
+public final class AbortTransactionPayload extends AbstractIdentifiablePayload<TransactionIdentifier> {
private static final Logger LOG = LoggerFactory.getLogger(AbortTransactionPayload.class);
@java.io.Serial
private static final long serialVersionUID = 1L;
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
-import com.google.common.io.ByteStreams;
-import java.io.DataInput;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import org.apache.commons.lang3.SerializationUtils;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.raft.messages.IdentifiablePayload;
-import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.concepts.Identifier;
/**
}
}
- @Deprecated(since = "7.0.0", forRemoval = true)
- protected abstract static class AbstractProxy<T extends Identifier> implements SerialForm {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- private byte[] serialized;
- private T identifier;
-
- public AbstractProxy() {
- // For Externalizable
- }
-
- protected AbstractProxy(final byte[] serialized) {
- this.serialized = requireNonNull(serialized);
- }
-
- @Override
- public final byte[] bytes() {
- return serialized;
- }
-
- @Override
- public final void readExternal(final byte[] bytes) throws IOException {
- serialized = requireNonNull(bytes);
- identifier = verifyNotNull(readIdentifier(ByteStreams.newDataInput(serialized)));
- }
-
- @Override
- public final Object readResolve() {
- return verifyNotNull(createObject(identifier, serialized));
- }
-
- protected abstract @NonNull T readIdentifier(@NonNull DataInput in) throws IOException;
-
- @SuppressWarnings("checkstyle:hiddenField")
- protected abstract @NonNull Identifiable<T> createObject(@NonNull T identifier, byte @NonNull[] serialized);
- }
-
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final byte @NonNull [] serialized;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
-import java.io.DataInput;
import java.io.IOException;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
-import org.opendaylight.controller.cluster.raft.persisted.LegacySerializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Robert Varga
*/
-public sealed class CloseLocalHistoryPayload extends AbstractIdentifiablePayload<LocalHistoryIdentifier> {
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Magnesium extends CloseLocalHistoryPayload implements LegacySerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- Magnesium(final LocalHistoryIdentifier historyId, final byte[] serialized) {
- super(historyId, serialized);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy extends AbstractProxy<LocalHistoryIdentifier> {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- protected LocalHistoryIdentifier readIdentifier(final DataInput in) throws IOException {
- return LocalHistoryIdentifier.readFrom(in);
- }
-
- @Override
- protected CloseLocalHistoryPayload createObject(final LocalHistoryIdentifier identifier,
- final byte[] serialized) {
- return new Magnesium(identifier, serialized);
- }
- }
-
+public final class CloseLocalHistoryPayload extends AbstractIdentifiablePayload<LocalHistoryIdentifier> {
private static final Logger LOG = LoggerFactory.getLogger(CloseLocalHistoryPayload.class);
@java.io.Serial
private static final long serialVersionUID = 1L;
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import static com.google.common.base.Verify.verifyNotNull;
import static com.google.common.math.IntMath.ceilingPowerOfTwo;
import static java.util.Objects.requireNonNull;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutputStream;
-import java.io.Externalizable;
import java.io.IOException;
-import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.Serializable;
-import java.io.StreamCorruptedException;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.Map.Entry;
import org.apache.commons.lang3.SerializationUtils;
import org.opendaylight.controller.cluster.io.ChunkedByteArray;
import org.opendaylight.controller.cluster.io.ChunkedOutputStream;
import org.opendaylight.controller.cluster.raft.messages.IdentifiablePayload;
-import org.opendaylight.controller.cluster.raft.persisted.LegacySerializable;
import org.opendaylight.yangtools.concepts.Either;
import org.opendaylight.yangtools.yang.data.api.schema.stream.ReusableStreamReceiver;
import org.opendaylight.yangtools.yang.data.impl.schema.ReusableImmutableNormalizedNodeStreamWriter;
return new CT(this);
}
- static sealed class Simple extends CommitTransactionPayload {
+ static final class Simple extends CommitTransactionPayload {
@java.io.Serial
private static final long serialVersionUID = 1L;
}
}
- static sealed class Chunked extends CommitTransactionPayload {
+ static final class Chunked extends CommitTransactionPayload {
@java.io.Serial
private static final long serialVersionUID = 1L;
// Hidden on purpose
}
}
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class SimpleMagnesium extends Simple implements LegacySerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- SimpleMagnesium(final byte[] serialized) {
- super(serialized);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class ChunkedMagnesium extends Chunked implements LegacySerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- ChunkedMagnesium(final ChunkedByteArray source) {
- super(source);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy implements Externalizable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- private CommitTransactionPayload payload;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException {
- final int length = in.readInt();
- if (length < 0) {
- throw new StreamCorruptedException("Invalid payload length " + length);
- } else if (length < MAX_ARRAY_SIZE) {
- final byte[] serialized = new byte[length];
- in.readFully(serialized);
- payload = new SimpleMagnesium(serialized);
- } else {
- payload = new ChunkedMagnesium(ChunkedByteArray.readFrom(in, length, MAX_ARRAY_SIZE));
- }
- }
-
- @java.io.Serial
- private Object readResolve() {
- return verifyNotNull(payload);
- }
- }
}
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
-import java.io.DataInput;
import java.io.IOException;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
-import org.opendaylight.controller.cluster.raft.persisted.LegacySerializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Robert Varga
*/
-public sealed class CreateLocalHistoryPayload extends AbstractIdentifiablePayload<LocalHistoryIdentifier> {
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Magnesium extends CreateLocalHistoryPayload implements LegacySerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- Magnesium(final LocalHistoryIdentifier historyId, final byte[] serialized) {
- super(historyId, serialized);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy extends AbstractProxy<LocalHistoryIdentifier> {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- protected LocalHistoryIdentifier readIdentifier(final DataInput in) throws IOException {
- return LocalHistoryIdentifier.readFrom(in);
- }
-
- @Override
- protected CreateLocalHistoryPayload createObject(final LocalHistoryIdentifier identifier,
- final byte[] serialized) {
- return new Magnesium(identifier, serialized);
- }
- }
-
+public final class CreateLocalHistoryPayload extends AbstractIdentifiablePayload<LocalHistoryIdentifier> {
private static final Logger LOG = LoggerFactory.getLogger(CreateLocalHistoryPayload.class);
@java.io.Serial
private static final long serialVersionUID = 1L;
import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.ArrayList;
+import org.opendaylight.controller.cluster.datastore.persisted.DatastoreSnapshot.ShardSnapshot;
+
/**
* Serialization proxy for {@link DatastoreSnapshot}.
*/
-final class DS implements DatastoreSnapshot.SerialForm {
+final class DS implements Externalizable {
@java.io.Serial
private static final long serialVersionUID = 1L;
}
@Override
- public DatastoreSnapshot datastoreSnapshot() {
- return datastoreSnapshot;
+ public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ final var type = (String) in.readObject();
+ final var snapshot = (ShardManagerSnapshot) in.readObject();
+
+ final int size = in.readInt();
+ var localShardSnapshots = new ArrayList<ShardSnapshot>(size);
+ for (int i = 0; i < size; i++) {
+ localShardSnapshots.add((ShardSnapshot) in.readObject());
+ }
+
+ datastoreSnapshot = new DatastoreSnapshot(type, snapshot, localShardSnapshots);
}
@Override
- public void resolveTo(final DatastoreSnapshot newDatastoreSnapshot) {
- datastoreSnapshot = requireNonNull(newDatastoreSnapshot);
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ out.writeObject(datastoreSnapshot.getType());
+ out.writeObject(datastoreSnapshot.getShardManagerSnapshot());
+
+ final var shardSnapshots = datastoreSnapshot.getShardSnapshots();
+ out.writeInt(shardSnapshots.size());
+ for (var shardSnapshot : shardSnapshots) {
+ out.writeObject(shardSnapshot);
+ }
}
- @Override
- public Object readResolve() {
+ @java.io.Serial
+ private Object readResolve() {
return verifyNotNull(datastoreSnapshot);
}
}
import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import org.opendaylight.controller.cluster.datastore.persisted.DatastoreSnapshot.ShardSnapshot;
import org.opendaylight.controller.cluster.raft.persisted.Snapshot;
/**
* Serialization proxy for {@link ShardDataTreeSnapshot}.
*/
-final class DSS implements ShardSnapshot.SerialForm {
+final class DSS implements Externalizable {
@java.io.Serial
private static final long serialVersionUID = 1L;
}
@Override
- public ShardSnapshot shardSnapshot() {
- return shardSnapshot;
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ out.writeObject(shardSnapshot.getName());
+ out.writeObject(shardSnapshot.getSnapshot());
}
@Override
- public void resolveTo(final String name, final Snapshot snapshot) {
- shardSnapshot = new ShardSnapshot(name, snapshot);
+ public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ shardSnapshot = new ShardSnapshot((String) in.readObject(), (Snapshot) in.readObject());
}
- @Override
- public Object readResolve() {
+ @java.io.Serial
+ private Object readResolve() {
return verifyNotNull(shardSnapshot);
}
}
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
import java.io.Serializable;
-import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
* @author Thomas Pantelis
*/
public final class DatastoreSnapshot implements Serializable {
- interface SerialForm extends Externalizable {
-
- DatastoreSnapshot datastoreSnapshot();
-
- Object readResolve();
-
- void resolveTo(@NonNull DatastoreSnapshot newDatastoreSnapshot);
-
- @Override
- default void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- final var type = (String)in.readObject();
- final var snapshot = (ShardManagerSnapshot) in.readObject();
-
- final int size = in.readInt();
- var localShardSnapshots = new ArrayList<ShardSnapshot>(size);
- for (int i = 0; i < size; i++) {
- localShardSnapshots.add((ShardSnapshot) in.readObject());
- }
-
- resolveTo(new DatastoreSnapshot(type, snapshot, localShardSnapshots));
- }
-
- @Override
- default void writeExternal(final ObjectOutput out) throws IOException {
- final var datastoreSnapshot = datastoreSnapshot();
- out.writeObject(datastoreSnapshot.type);
- out.writeObject(datastoreSnapshot.shardManagerSnapshot);
-
- out.writeInt(datastoreSnapshot.shardSnapshots.size());
- for (ShardSnapshot shardSnapshot: datastoreSnapshot.shardSnapshots) {
- out.writeObject(shardSnapshot);
- }
- }
- }
-
- private static final class Proxy implements SerialForm {
- private static final long serialVersionUID = 1L;
-
- private DatastoreSnapshot datastoreSnapshot;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- public DatastoreSnapshot datastoreSnapshot() {
- return datastoreSnapshot;
- }
-
- @Override
- public void resolveTo(final DatastoreSnapshot newDatastoreSnapshot) {
- datastoreSnapshot = requireNonNull(newDatastoreSnapshot);
- }
-
- @Override
- public Object readResolve() {
- return verifyNotNull(datastoreSnapshot);
- }
- }
-
@java.io.Serial
private static final long serialVersionUID = 1L;
}
public static final class ShardSnapshot implements Serializable {
- interface SerialForm extends Externalizable {
-
- ShardSnapshot shardSnapshot();
-
- Object readResolve();
-
- void resolveTo(String name, Snapshot snapshot);
-
- @Override
- default void writeExternal(final ObjectOutput out) throws IOException {
- final var shardSnapshot = shardSnapshot();
- out.writeObject(shardSnapshot.name);
- out.writeObject(shardSnapshot.snapshot);
- }
-
- @Override
- default void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- resolveTo((String) in.readObject(), (Snapshot) in.readObject());
- }
- }
-
- private static final class Proxy implements SerialForm {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- private ShardSnapshot shardSnapshot;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- public ShardSnapshot shardSnapshot() {
- return shardSnapshot;
- }
-
- @Override
- public void resolveTo(final String name, final Snapshot snapshot) {
- shardSnapshot = new ShardSnapshot(name, snapshot);
- }
-
- @Override
- public Object readResolve() {
- return verifyNotNull(shardSnapshot);
- }
- }
-
@java.io.Serial
private static final long serialVersionUID = 1L;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
-import java.io.DataInput;
import java.io.IOException;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
-import org.opendaylight.controller.cluster.raft.persisted.LegacySerializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public sealed class DisableTrackingPayload extends AbstractIdentifiablePayload<ClientIdentifier> {
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Magnesium extends DisableTrackingPayload implements LegacySerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- Magnesium(final ClientIdentifier clientId, final byte[] serialized) {
- super(clientId, serialized);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy extends AbstractProxy<ClientIdentifier> {
- @java.io.Serial
- private static final long serialVersionUID = -5490519942445085251L;
-
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- protected ClientIdentifier readIdentifier(final DataInput in) throws IOException {
- return ClientIdentifier.readFrom(in);
- }
-
- @Override
- protected DisableTrackingPayload createObject(final ClientIdentifier identifier,
- final byte[] serialized) {
- return new Magnesium(identifier, serialized);
- }
- }
-
+public final class DisableTrackingPayload extends AbstractIdentifiablePayload<ClientIdentifier> {
private static final Logger LOG = LoggerFactory.getLogger(DisableTrackingPayload.class);
@java.io.Serial
private static final long serialVersionUID = 1L;
import com.google.common.collect.ImmutableList;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-public final class FrontendShardDataTreeSnapshotMetadata extends
- ShardDataTreeSnapshotMetadata<FrontendShardDataTreeSnapshotMetadata> {
- private static final class Proxy implements Externalizable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- private List<FrontendClientMetadata> clients;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException {
- final int size = in.readInt();
- final List<FrontendClientMetadata> readedClients = new ArrayList<>(size);
- for (int i = 0; i < size ; ++i) {
- readedClients.add(FrontendClientMetadata.readFrom(in));
- }
- clients = ImmutableList.copyOf(readedClients);
- }
-
- @java.io.Serial
- private Object readResolve() {
- return new FrontendShardDataTreeSnapshotMetadata(clients);
- }
- }
-
+public final class FrontendShardDataTreeSnapshotMetadata
+ extends ShardDataTreeSnapshotMetadata<FrontendShardDataTreeSnapshotMetadata> {
@java.io.Serial
private static final long serialVersionUID = 1L;
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableMap.Builder;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
import java.io.Serializable;
-import java.io.StreamCorruptedException;
import java.util.Map;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput;
-import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* An {@link AbstractVersionedShardDataTreeSnapshot} which contains additional metadata.
@Beta
public final class MetadataShardDataTreeSnapshot extends AbstractVersionedShardDataTreeSnapshot
implements Serializable {
- private static final class Proxy implements Externalizable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
- private static final Logger LOG = LoggerFactory.getLogger(MetadataShardDataTreeSnapshot.class);
-
- private Map<Class<? extends ShardDataTreeSnapshotMetadata<?>>, ShardDataTreeSnapshotMetadata<?>> metadata;
- private NormalizedNodeStreamVersion version;
- private NormalizedNode rootNode;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- final int metaSize = in.readInt();
- checkArgument(metaSize >= 0, "Invalid negative metadata map length %s", metaSize);
-
- // Default pre-allocate is 4, which should be fine
- final Builder<Class<? extends ShardDataTreeSnapshotMetadata<?>>, ShardDataTreeSnapshotMetadata<?>>
- metaBuilder = ImmutableMap.builder();
- for (int i = 0; i < metaSize; ++i) {
- final ShardDataTreeSnapshotMetadata<?> m = (ShardDataTreeSnapshotMetadata<?>) in.readObject();
- if (m != null) {
- metaBuilder.put(m.getType(), m);
- } else {
- LOG.warn("Skipping null metadata");
- }
- }
-
- metadata = metaBuilder.build();
- final boolean present = in.readBoolean();
- if (!present) {
- throw new StreamCorruptedException("Unexpected missing root node");
- }
-
- final NormalizedNodeDataInput stream = NormalizedNodeDataInput.newDataInput(in);
- version = stream.getVersion();
- rootNode = stream.readNormalizedNode();
- }
-
- private Object readResolve() {
- return new MetadataShardDataTreeSnapshot(rootNode, metadata);
- }
- }
-
@java.io.Serial
private static final long serialVersionUID = 1L;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
-import java.io.DataInput;
import java.io.IOException;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
-import org.opendaylight.controller.cluster.raft.persisted.LegacySerializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Robert Varga
*/
-public sealed class PurgeLocalHistoryPayload extends AbstractIdentifiablePayload<LocalHistoryIdentifier> {
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Magnesium extends PurgeLocalHistoryPayload implements LegacySerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- Magnesium(final LocalHistoryIdentifier historyId, final byte[] serialized) {
- super(historyId, serialized);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy extends AbstractProxy<LocalHistoryIdentifier> {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- protected LocalHistoryIdentifier readIdentifier(final DataInput in) throws IOException {
- return LocalHistoryIdentifier.readFrom(in);
- }
-
- @Override
- protected PurgeLocalHistoryPayload createObject(final LocalHistoryIdentifier identifier,
- final byte[] serialized) {
- return new Magnesium(identifier, serialized);
- }
- }
-
+public final class PurgeLocalHistoryPayload extends AbstractIdentifiablePayload<LocalHistoryIdentifier> {
private static final Logger LOG = LoggerFactory.getLogger(PurgeLocalHistoryPayload.class);
@java.io.Serial
private static final long serialVersionUID = 1L;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
-import java.io.DataInput;
import java.io.IOException;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.controller.cluster.raft.persisted.LegacySerializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Robert Varga
*/
-public sealed class PurgeTransactionPayload extends AbstractIdentifiablePayload<TransactionIdentifier> {
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Magnesium extends PurgeTransactionPayload implements LegacySerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- Magnesium(final TransactionIdentifier transactionId, final byte[] serialized) {
- super(transactionId, serialized);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy extends AbstractProxy<TransactionIdentifier> {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- protected TransactionIdentifier readIdentifier(final DataInput in) throws IOException {
- return TransactionIdentifier.readFrom(in);
- }
-
- @Override
- protected PurgeTransactionPayload createObject(final TransactionIdentifier identifier,
- final byte[] serialized) {
- return new Magnesium(identifier, serialized);
- }
- }
-
+public final class PurgeTransactionPayload extends AbstractIdentifiablePayload<TransactionIdentifier> {
private static final Logger LOG = LoggerFactory.getLogger(PurgeTransactionPayload.class);
@java.io.Serial
private static final long serialVersionUID = 1L;
import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
-import java.util.List;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.ArrayList;
/**
* Serialization proxy for {@link ShardManagerSnapshot}.
*/
-final class SM implements ShardManagerSnapshot.SerializedForm {
+final class SM implements Externalizable {
@java.io.Serial
private static final long serialVersionUID = 1L;
}
@Override
- public List<String> shardNames() {
- return snapshot.getShardList();
+ public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ final int size = in.readInt();
+ final var shardList = new ArrayList<String>(size);
+ for (int i = 0; i < size; i++) {
+ shardList.add((String) in.readObject());
+ }
+ snapshot = new ShardManagerSnapshot(shardList);
}
@Override
- public void resolveTo(final ShardManagerSnapshot newSnapshot) {
- snapshot = requireNonNull(newSnapshot);
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ final var shardList = snapshot.getShardList();
+ out.writeInt(shardList.size());
+ for (var shardName : shardList) {
+ out.writeObject(shardName);
+ }
}
- @Override
- public Object readResolve() {
+ @java.io.Serial
+ private Object readResolve() {
return verifyNotNull(snapshot);
}
}
import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+
/**
* Serialization proxy for {@link ShardSnapshotState}.
*/
-final class SS implements ShardSnapshotState.SerialForm {
+final class SS implements Externalizable {
@java.io.Serial
private static final long serialVersionUID = 1L;
}
@Override
- public ShardSnapshotState snapshotState() {
- return snapshotState;
+ public void readExternal(final ObjectInput in) throws IOException {
+ snapshotState = ShardDataTreeSnapshot.deserialize(in);
}
@Override
- public void resolveTo(final ShardSnapshotState newSnapshotState) {
- snapshotState = requireNonNull(newSnapshotState);
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ snapshotState.getSnapshot().serialize(out);
}
- @Override
- public Object readResolve() {
+ @java.io.Serial
+ private Object readResolve() {
return verifyNotNull(snapshotState);
}
}
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.collect.ImmutableList;
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
import java.io.Serializable;
-import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.cluster.raft.persisted.MigratedSerializable;
/**
* Represents the persisted snapshot state for the ShardManager.
*
* @author Thomas Pantelis
*/
-public sealed class ShardManagerSnapshot implements Serializable {
- interface SerializedForm extends Externalizable {
- /**
- * Return the serial form of this object contents, corresponding to {@link ShardManagerSnapshot#shardList}.
- *
- * @return List of shards names.
- */
- List<String> shardNames();
-
- /**
- * Resolve this proxy to an actual {@link ShardManagerSnapshot}. Implementations can rely on the object to be
- * set via {@link #resolveTo(ShardManagerSnapshot)}.
- *
- * @return A snapshot
- */
- Object readResolve();
-
- /**
- * Set this proxy to return {@code snapshot} on next {@link #readResolve()}.
- *
- * @param newSnapshot Snapshot to set
- */
- void resolveTo(@NonNull ShardManagerSnapshot newSnapshot);
-
- @Override
- default void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- final int size = in.readInt();
- final var shardList = new ArrayList<String>(size);
- for (int i = 0; i < size; i++) {
- shardList.add((String) in.readObject());
- }
- resolveTo(new ShardManagerSnapshot(shardList));
- }
-
- @Override
- default void writeExternal(final ObjectOutput out) throws IOException {
- final var shardList = shardNames();
- out.writeInt(shardList.size());
- for (var shardName : shardList) {
- out.writeObject(shardName);
- }
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Magnesium extends ShardManagerSnapshot implements MigratedSerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- Magnesium(final List<String> shardList) {
- super(shardList);
- }
-
- @Override
- public boolean isMigrated() {
- return true;
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy implements SerializedForm {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- private ShardManagerSnapshot snapshot = null;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- public List<String> shardNames() {
- return snapshot.getShardList();
- }
-
- @Override
- public void resolveTo(final ShardManagerSnapshot newSnapshot) {
- snapshot = requireNonNull(newSnapshot);
- }
-
- @Override
- public Object readResolve() {
- return new Magnesium(snapshot.getShardList());
- }
- }
-
+public final class ShardManagerSnapshot implements Serializable {
@java.io.Serial
private static final long serialVersionUID = 1L;
this.shardList = ImmutableList.copyOf(shardList);
}
- public final List<String> getShardList() {
+ public List<String> getShardList() {
return shardList;
}
@java.io.Serial
- public final Object writeReplace() {
+ private Object writeReplace() {
return new SM(this);
}
@Override
- public final String toString() {
+ public String toString() {
return "ShardManagerSnapshot [ShardList = " + shardList + " ]";
}
}
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.VisibleForTesting;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.raft.persisted.Snapshot;
* @author Thomas Pantelis
*/
public final class ShardSnapshotState implements Snapshot.State {
- interface SerialForm extends Externalizable {
-
- ShardSnapshotState snapshotState();
-
- void resolveTo(@NonNull ShardSnapshotState newSnapshotState);
-
- Object readResolve();
-
- @Override
- default void readExternal(final ObjectInput in) throws IOException {
- resolveTo(ShardDataTreeSnapshot.deserialize(in));
- }
-
- @Override
- default void writeExternal(final ObjectOutput out) throws IOException {
- snapshotState().getSnapshot().serialize(out);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy implements SerialForm {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- private ShardSnapshotState snapshotState;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- public ShardSnapshotState snapshotState() {
- return snapshotState;
- }
-
- @Override
- public void resolveTo(final ShardSnapshotState newSnapshotState) {
- snapshotState = requireNonNull(newSnapshotState);
- }
-
- @Override
- public Object readResolve() {
- return verifyNotNull(snapshotState);
- }
- }
-
@java.io.Serial
private static final long serialVersionUID = 1L;
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.io.ByteStreams;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.DataInput;
import java.io.IOException;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
import org.opendaylight.controller.cluster.datastore.utils.ImmutableUnsignedLongSet;
-import org.opendaylight.controller.cluster.raft.persisted.LegacySerializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* for other purposes. It contains a {@link LocalHistoryIdentifier} and a list of transaction identifiers within that
* local history.
*/
-public sealed class SkipTransactionsPayload extends AbstractIdentifiablePayload<LocalHistoryIdentifier> {
- private static final class Magnesium extends SkipTransactionsPayload implements LegacySerializable {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- Magnesium(final LocalHistoryIdentifier historyId, final byte[] serialized,
- final ImmutableUnsignedLongSet transactionIds) {
- super(historyId, serialized, transactionIds);
- }
- }
-
- @Deprecated(since = "7.0.0", forRemoval = true)
- private static final class Proxy extends AbstractProxy<LocalHistoryIdentifier> {
- @java.io.Serial
- private static final long serialVersionUID = 1L;
-
- private ImmutableUnsignedLongSet transactionIds;
-
- // checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
- // redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
- @SuppressWarnings("checkstyle:RedundantModifier")
- public Proxy() {
- // For Externalizable
- }
-
- @Override
- protected LocalHistoryIdentifier readIdentifier(final DataInput in) throws IOException {
- final var id = LocalHistoryIdentifier.readFrom(in);
- transactionIds = ImmutableUnsignedLongSet.readFrom(in);
- return id;
- }
-
- @Override
- protected SkipTransactionsPayload createObject(final LocalHistoryIdentifier identifier,
- final byte[] serialized) {
- return new Magnesium(identifier, serialized, verifyNotNull(transactionIds));
- }
- }
-
+public final class SkipTransactionsPayload extends AbstractIdentifiablePayload<LocalHistoryIdentifier> {
private static final Logger LOG = LoggerFactory.getLogger(SkipTransactionsPayload.class);
@java.io.Serial
private static final long serialVersionUID = 1L;
Code Review / controller.git / commitdiff