};
}
+ /**
+ * Return {@code true} if this version is earier than some {@code other} version.
+ *
+ * @param other Other {@link ABIVersion}
+ * @return {@code true} if {@code other is later}
+ * @throws NullPointerException if {@code other} is null
+ */
+ public boolean lt(final @NonNull ABIVersion other) {
+ return compareTo(other) < 0;
+ }
+
@Override
public void writeTo(final DataOutput out) throws IOException {
out.writeShort(value);
import static java.util.Objects.requireNonNull;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
/**
* Abstract base exception used for reporting version mismatches from {@link ABIVersion}.
*/
public abstract class AbstractVersionException extends Exception {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull ABIVersion closestVersion;
*/
package org.opendaylight.controller.cluster.access;
-import java.io.Serial;
-
/**
* Exception thrown from {@link ABIVersion#valueOf(short)} when the specified version is too new to be supported
* by the codebase.
*/
public final class FutureVersionException extends AbstractVersionException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- FutureVersionException(final short version, ABIVersion closest) {
+ FutureVersionException(final short version, final ABIVersion closest) {
super("Version " + Short.toUnsignedInt(version) + " is too new", version, closest);
}
}
*/
package org.opendaylight.controller.cluster.access;
-import java.io.Serial;
-
/**
* Exception thrown from {@link ABIVersion#valueOf(short)} when the specified version is too old and no longer
* supported by the codebase.
- *
- * @author Robert Varga
*/
public final class PastVersionException extends AbstractVersionException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
PastVersionException(final short version, final ABIVersion closest) {
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* not important for single transactions, but is critical to ensure transaction ordering within local histories.
*/
public final class AbortLocalTransactionRequest extends AbstractLocalTransactionRequest<AbortLocalTransactionRequest> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public AbortLocalTransactionRequest(final @NonNull TransactionIdentifier identifier,
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.DataInput;
-import java.io.IOException;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestProxy;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
* @param <T> Message type
*/
abstract class AbstractLocalHistoryRequestProxy<T extends LocalHistoryRequest<T>>
- extends AbstractRequestProxy<LocalHistoryIdentifier, T> {
- @Serial
+ extends AbstractRequestProxy<LocalHistoryIdentifier, T> implements LocalHistoryRequest.SerialForm<T> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
protected AbstractLocalHistoryRequestProxy() {
AbstractLocalHistoryRequestProxy(final T request) {
super(request);
}
-
- @Override
- protected final LocalHistoryIdentifier readTarget(final DataInput in) throws IOException {
- return LocalHistoryIdentifier.readFrom(in);
- }
}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.Request;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
*/
public abstract class AbstractLocalTransactionRequest<T extends AbstractLocalTransactionRequest<T>>
extends TransactionRequest<T> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
AbstractLocalTransactionRequest(final TransactionIdentifier identifier, final long sequence,
}
@Override
- protected final AbstractTransactionRequestProxy<T> externalizableProxy(final ABIVersion version) {
+ protected final SerialForm<T> externalizableProxy(final ABIVersion version) {
throw new UnsupportedOperationException("Local transaction request " + this + " should never be serialized");
}
import akka.actor.ActorRef;
import com.google.common.base.MoreObjects.ToStringHelper;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput;
/**
* Abstract base class for {@link TransactionRequest}s accessing data as visible in the isolated context of a particular
*/
public abstract class AbstractReadPathTransactionRequest<T extends AbstractReadPathTransactionRequest<T>>
extends AbstractReadTransactionRequest<T> {
- @Serial
+ interface SerialForm<T extends AbstractReadPathTransactionRequest<T>>
+ extends AbstractReadTransactionRequest.SerialForm<T> {
+
+ @Override
+ default T readExternal(final ObjectInput in, final TransactionIdentifier target, final long sequence,
+ final ActorRef replyTo, final boolean snapshotOnly) throws IOException {
+ return readExternal(in, target, sequence, replyTo, snapshotOnly,
+ NormalizedNodeDataInput.newDataInput(in).readYangInstanceIdentifier());
+ }
+
+ @NonNull T readExternal(@NonNull ObjectInput in, @NonNull TransactionIdentifier target, long sequence,
+ @NonNull ActorRef replyTo, boolean snapshotOnly, @NonNull YangInstanceIdentifier path) throws IOException;
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final T msg) throws IOException {
+ AbstractReadTransactionRequest.SerialForm.super.writeExternal(out, msg);
+ try (var nnout = msg.getVersion().getStreamVersion().newDataOutput(out)) {
+ nnout.writeYangInstanceIdentifier(msg.getPath());
+ }
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull YangInstanceIdentifier path;
}
@Override
- protected abstract AbstractReadTransactionRequestProxyV1<T> externalizableProxy(ABIVersion version);
+ protected abstract SerialForm<T> externalizableProxy(ABIVersion version);
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput;
-import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataOutput;
-import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion;
-
/**
* Abstract base class for serialization proxies associated with {@link AbstractReadTransactionRequest}s. It implements
* the initial (Boron) serialization format.
* @param <T> Message type
*/
abstract class AbstractReadPathTransactionRequestProxyV1<T extends AbstractReadPathTransactionRequest<T>>
- extends AbstractReadTransactionRequestProxyV1<T> {
- @Serial
+ extends AbstractReadTransactionRequestProxyV1<T> implements AbstractReadPathTransactionRequest.SerialForm<T> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private YangInstanceIdentifier path;
- private transient NormalizedNodeStreamVersion streamVersion;
-
protected AbstractReadPathTransactionRequestProxyV1() {
// For Externalizable
}
AbstractReadPathTransactionRequestProxyV1(final T request) {
super(request);
- path = request.getPath();
- streamVersion = request.getVersion().getStreamVersion();
}
-
- @Override
- public final void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
- try (NormalizedNodeDataOutput nnout = streamVersion.newDataOutput(out)) {
- nnout.writeYangInstanceIdentifier(path);
- }
- }
-
- @Override
- public final void readExternal(final ObjectInput in) throws ClassNotFoundException, IOException {
- super.readExternal(in);
- path = NormalizedNodeDataInput.newDataInput(in).readYangInstanceIdentifier();
- }
-
- @Override
- protected final T createReadRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyTo, final boolean snapshotOnly) {
- return createReadPathRequest(target, sequence, replyTo, path, snapshotOnly);
- }
-
- abstract T createReadPathRequest(TransactionIdentifier target, long sequence, ActorRef replyTo,
- YangInstanceIdentifier requestPath, boolean snapshotOnly);
}
import akka.actor.ActorRef;
import com.google.common.base.MoreObjects.ToStringHelper;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
*/
public abstract class AbstractReadTransactionRequest<T extends AbstractReadTransactionRequest<T>>
extends TransactionRequest<T> {
- @Serial
+ interface SerialForm<T extends AbstractReadTransactionRequest<T>> extends TransactionRequest.SerialForm<T> {
+ @Override
+ default T readExternal(final ObjectInput in, final TransactionIdentifier target, final long sequence,
+ final ActorRef replyTo) throws IOException {
+ return readExternal(in, target, sequence, replyTo, in.readBoolean());
+ }
+
+ @NonNull T readExternal(@NonNull ObjectInput in, @NonNull TransactionIdentifier target, long sequence,
+ @NonNull ActorRef replyTo, boolean snapshotOnly) throws IOException;
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final T msg) throws IOException {
+ TransactionRequest.SerialForm.super.writeExternal(out, msg);
+ out.writeBoolean(msg.isSnapshotOnly());
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final boolean snapshotOnly;
}
@Override
- protected abstract AbstractReadTransactionRequestProxyV1<T> externalizableProxy(ABIVersion version);
+ protected abstract SerialForm<T> externalizableProxy(ABIVersion version);
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Abstract base class for serialization proxies associated with {@link AbstractReadTransactionRequest}s. It implements
* the initial (Boron) serialization format.
* @param <T> Message type
*/
abstract class AbstractReadTransactionRequestProxyV1<T extends AbstractReadTransactionRequest<T>>
- extends AbstractTransactionRequestProxy<T> {
- @Serial
+ extends AbstractTransactionRequestProxy<T> implements AbstractReadTransactionRequest.SerialForm<T> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private boolean snapshotOnly;
-
protected AbstractReadTransactionRequestProxyV1() {
// For Externalizable
}
AbstractReadTransactionRequestProxyV1(final T request) {
super(request);
- snapshotOnly = request.isSnapshotOnly();
}
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
- out.writeBoolean(snapshotOnly);
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws ClassNotFoundException, IOException {
- super.readExternal(in);
- snapshotOnly = in.readBoolean();
- }
-
- @Override
- protected final T createRequest(final TransactionIdentifier target, final long sequence, final ActorRef replyTo) {
- return createReadRequest(target, sequence, replyTo, snapshotOnly);
- }
-
- @SuppressWarnings("checkstyle:hiddenField")
- abstract T createReadRequest(TransactionIdentifier target, long sequence, ActorRef replyTo, boolean snapshotOnly);
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.DataInput;
-import java.io.IOException;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestProxy;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @param <T> Message type
*/
abstract class AbstractTransactionRequestProxy<T extends TransactionRequest<T>>
- extends AbstractRequestProxy<TransactionIdentifier, T> {
- @Serial
+ extends AbstractRequestProxy<TransactionIdentifier, T> implements TransactionRequest.SerialForm<T> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
AbstractTransactionRequestProxy() {
AbstractTransactionRequestProxy(final T request) {
super(request);
}
-
- @Override
- protected final TransactionIdentifier readTarget(final DataInput in) throws IOException {
- return TransactionIdentifier.readFrom(in);
- }
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.DataInput;
-import java.io.IOException;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractSuccessProxy;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @param <T> Message type
*/
abstract class AbstractTransactionSuccessProxy<T extends TransactionSuccess<T>>
- extends AbstractSuccessProxy<TransactionIdentifier, T> {
- @Serial
+ extends AbstractSuccessProxy<TransactionIdentifier, T> implements TransactionSuccess.SerialForm<T> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
AbstractTransactionSuccessProxy() {
AbstractTransactionSuccessProxy(final T request) {
super(request);
}
-
- @Override
- protected final TransactionIdentifier readTarget(final DataInput in) throws IOException {
- return TransactionIdentifier.readFrom(in);
- }
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link ConnectClientFailure}. It implements the Chlorine SR2 serialization format.
+ */
+final class CCF implements ConnectClientFailure.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ConnectClientFailure message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public CCF() {
+ // for Externalizable
+ }
+
+ CCF(final ConnectClientFailure request) {
+ message = requireNonNull(request);
+ }
+
+ @Override
+ public ConnectClientFailure message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final ConnectClientFailure message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link ConnectClientRequest}. It implements the Chlorine SR2 serialization format.
+ */
+final class CCR implements ConnectClientRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ConnectClientRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public CCR() {
+ // for Externalizable
+ }
+
+ CCR(final ConnectClientRequest request) {
+ message = requireNonNull(request);
+ }
+
+ @Override
+ public ConnectClientRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final ConnectClientRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link ConnectClientSuccess}. It implements the Chlorine SR2 serialization format.
+ */
+final class CCS implements ConnectClientSuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ConnectClientSuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public CCS() {
+ // for Externalizable
+ }
+
+ CCS(final ConnectClientSuccess request) {
+ message = requireNonNull(request);
+ }
+
+ @Override
+ public ConnectClientSuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final ConnectClientSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link CreateLocalHistoryRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class CHR implements CreateLocalHistoryRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private CreateLocalHistoryRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public CHR() {
+ // For Externalizable
+ }
+
+ CHR(final CreateLocalHistoryRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public CreateLocalHistoryRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final CreateLocalHistoryRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
/**
* leader moved before the frontend retried the corresponding request.
*/
public final class ClosedTransactionException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final boolean successful;
import akka.actor.ActorRef;
import com.google.common.base.MoreObjects.ToStringHelper;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.Serial;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
*/
public final class CommitLocalTransactionRequest
extends AbstractLocalTransactionRequest<CommitLocalTransactionRequest> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
@SuppressFBWarnings(value = "SE_BAD_FIELD", justification = "This field is not Serializable but this class "
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.IOException;
import org.opendaylight.controller.cluster.access.ABIVersion;
-import org.opendaylight.controller.cluster.access.concepts.AbstractRequestFailureProxy;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
import org.opendaylight.controller.cluster.access.concepts.RequestFailure;
* A {@link RequestFailure} reported when {@link ConnectClientRequest} fails.
*/
public final class ConnectClientFailure extends RequestFailure<ClientIdentifier, ConnectClientFailure> {
- @Serial
+ interface SerialForm extends RequestFailure.SerialForm<ClientIdentifier, ConnectClientFailure> {
+ @Override
+ default ClientIdentifier readTarget(final DataInput in) throws IOException {
+ return ClientIdentifier.readFrom(in);
+ }
+
+ @Override
+ default ConnectClientFailure createFailure(final ClientIdentifier target, final long sequence,
+ final RequestException cause) {
+ return new ConnectClientFailure(target, sequence, cause);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
ConnectClientFailure(final ClientIdentifier target, final long sequence, final RequestException cause) {
}
@Override
- protected AbstractRequestFailureProxy<ClientIdentifier, ConnectClientFailure> externalizableProxy(
- final ABIVersion version) {
- return new ConnectClientFailureProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new CCF(this) : new ConnectClientFailureProxyV1(this);
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.DataInput;
-import java.io.IOException;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestFailureProxy;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
-import org.opendaylight.controller.cluster.access.concepts.RequestException;
/**
* Serialization proxy for use with {@link ConnectClientFailure}. This class implements initial (Boron) serialization
*
* @author Robert Varga
*/
-final class ConnectClientFailureProxyV1 extends AbstractRequestFailureProxy<ClientIdentifier, ConnectClientFailure> {
- @Serial
+final class ConnectClientFailureProxyV1 extends AbstractRequestFailureProxy<ClientIdentifier, ConnectClientFailure>
+ implements ConnectClientFailure.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 2688639416324657256L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
ConnectClientFailureProxyV1(final ConnectClientFailure failure) {
super(failure);
}
-
- @Override
- protected ConnectClientFailure createFailure(final ClientIdentifier target, final long sequence,
- final RequestException cause) {
- return new ConnectClientFailure(target, sequence, cause);
- }
-
- @Override
- protected ClientIdentifier readTarget(final DataInput in) throws IOException {
- return ClientIdentifier.readFrom(in);
- }
}
import akka.actor.ActorRef;
import com.google.common.base.MoreObjects.ToStringHelper;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import org.opendaylight.controller.cluster.access.ABIVersion;
-import org.opendaylight.controller.cluster.access.concepts.AbstractRequestProxy;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
import org.opendaylight.controller.cluster.access.concepts.Request;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
* It also includes request stream sequencing information.
*/
public final class ConnectClientRequest extends Request<ClientIdentifier, ConnectClientRequest> {
- @Serial
+ interface SerialForm extends Request.SerialForm<ClientIdentifier, ConnectClientRequest> {
+ @Override
+ default ConnectClientRequest readExternal(final ObjectInput in, final ClientIdentifier target,
+ final long sequence, final ActorRef replyTo) throws IOException {
+ return new ConnectClientRequest(target, sequence, replyTo, ABIVersion.inexactReadFrom(in),
+ ABIVersion.inexactReadFrom(in));
+ }
+
+ @Override
+ default ClientIdentifier readTarget(final DataInput in) throws IOException {
+ return ClientIdentifier.readFrom(in);
+ }
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final ConnectClientRequest msg) throws IOException {
+ Request.SerialForm.super.writeExternal(out, msg);
+ msg.getMinVersion().writeTo(out);
+ msg.getMaxVersion().writeTo(out);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final ABIVersion minVersion;
}
@Override
- protected AbstractRequestProxy<ClientIdentifier, ConnectClientRequest> externalizableProxy(
- final ABIVersion version) {
- return new ConnectClientRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new CCR(this) : new ConnectClientRequestProxyV1(this);
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.DataInput;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestProxy;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
*
* @author Robert Varga
*/
-final class ConnectClientRequestProxyV1 extends AbstractRequestProxy<ClientIdentifier, ConnectClientRequest> {
- @Serial
+final class ConnectClientRequestProxyV1 extends AbstractRequestProxy<ClientIdentifier, ConnectClientRequest>
+ implements ConnectClientRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 8439729661327852159L;
- private ABIVersion minVersion;
- private ABIVersion maxVersion;
-
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
@SuppressWarnings("checkstyle:RedundantModifier")
ConnectClientRequestProxyV1(final ConnectClientRequest request) {
super(request);
- minVersion = request.getMinVersion();
- maxVersion = request.getMaxVersion();
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
- minVersion.writeTo(out);
- maxVersion.writeTo(out);
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
- minVersion = ABIVersion.inexactReadFrom(in);
- maxVersion = ABIVersion.inexactReadFrom(in);
- }
-
- @Override
- protected ConnectClientRequest createRequest(final ClientIdentifier target, final long sequence,
- final ActorRef replyTo) {
- return new ConnectClientRequest(target, sequence, replyTo, minVersion, maxVersion);
- }
-
- @Override
- protected ClientIdentifier readTarget(final DataInput in) throws IOException {
- return ClientIdentifier.readFrom(in);
}
}
import akka.actor.ActorRef;
import akka.actor.ActorSelection;
+import akka.serialization.JavaSerializer;
+import akka.serialization.Serialization;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.collect.ImmutableList;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
* fail, the client can try accessing the provided alternates.
*/
public final class ConnectClientSuccess extends RequestSuccess<ClientIdentifier, ConnectClientSuccess> {
- @Serial
+ interface SerialForm extends RequestSuccess.SerialForm<ClientIdentifier, ConnectClientSuccess> {
+ @Override
+ default ClientIdentifier readTarget(final DataInput in) throws IOException {
+ return ClientIdentifier.readFrom(in);
+ }
+
+ @Override
+ default ConnectClientSuccess readExternal(final ObjectInput in, final ClientIdentifier target,
+ final long sequence) throws IOException, ClassNotFoundException {
+ final var backend = JavaSerializer.currentSystem().value().provider()
+ .resolveActorRef((String) in.readObject());
+ final var maxMessages = in.readInt();
+
+ final int alternatesSize = in.readInt();
+ final var alternates = new ArrayList<ActorSelection>(alternatesSize);
+ for (int i = 0; i < alternatesSize; ++i) {
+ alternates.add(ActorSelection.apply(ActorRef.noSender(), (String)in.readObject()));
+ }
+
+ return new ConnectClientSuccess(target, sequence, backend, alternates, maxMessages, null);
+ }
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final ConnectClientSuccess msg) throws IOException {
+ out.writeObject(Serialization.serializedActorPath(msg.backend));
+ out.writeInt(msg.maxMessages);
+
+ out.writeInt(msg.alternates.size());
+ for (ActorSelection b : msg.alternates) {
+ out.writeObject(b.toSerializationFormat());
+ }
+
+ // We are ignoring the DataTree, it is not serializable anyway
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull ImmutableList<ActorSelection> alternates;
private final @NonNull ActorRef backend;
private final int maxMessages;
+ private ConnectClientSuccess(final ConnectClientSuccess success, final ABIVersion version) {
+ super(success, version);
+ alternates = success.alternates;
+ dataTree = success.dataTree;
+ backend = success.backend;
+ maxMessages = success.maxMessages;
+ }
+
ConnectClientSuccess(final ClientIdentifier target, final long sequence, final ActorRef backend,
final List<ActorSelection> alternates, final int maxMessages, final ReadOnlyDataTree dataTree) {
super(target, sequence);
}
@Override
- protected ConnectClientSuccessProxyV1 externalizableProxy(final ABIVersion version) {
- return new ConnectClientSuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new CCS(this) : new ConnectClientSuccessProxyV1(this);
}
@Override
protected ConnectClientSuccess cloneAsVersion(final ABIVersion version) {
- return this;
+ return new ConnectClientSuccess(this, version);
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import akka.actor.ActorSelection;
-import akka.serialization.JavaSerializer;
-import akka.serialization.Serialization;
-import java.io.DataInput;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.List;
import org.opendaylight.controller.cluster.access.concepts.AbstractSuccessProxy;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
*
* @author Robert Varga
*/
-final class ConnectClientSuccessProxyV1 extends AbstractSuccessProxy<ClientIdentifier, ConnectClientSuccess> {
- @Serial
+final class ConnectClientSuccessProxyV1 extends AbstractSuccessProxy<ClientIdentifier, ConnectClientSuccess>
+ implements ConnectClientSuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private List<ActorSelection> alternates;
- private ActorRef backend;
- private int maxMessages;
-
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
@SuppressWarnings("checkstyle:RedundantModifier")
ConnectClientSuccessProxyV1(final ConnectClientSuccess success) {
super(success);
- alternates = success.getAlternates();
- backend = success.getBackend();
- maxMessages = success.getMaxMessages();
- // We are ignoring the DataTree, it is not serializable anyway
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- out.writeObject(Serialization.serializedActorPath(backend));
- out.writeInt(maxMessages);
-
- out.writeInt(alternates.size());
- for (ActorSelection b : alternates) {
- out.writeObject(b.toSerializationFormat());
- }
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- backend = JavaSerializer.currentSystem().value().provider().resolveActorRef((String) in.readObject());
- maxMessages = in.readInt();
-
- final int alternatesSize = in.readInt();
- alternates = new ArrayList<>(alternatesSize);
- for (int i = 0; i < alternatesSize; ++i) {
- alternates.add(ActorSelection.apply(ActorRef.noSender(), (String)in.readObject()));
- }
- }
-
- @Override
- protected ConnectClientSuccess createSuccess(final ClientIdentifier target, final long sequence) {
- return new ConnectClientSuccess(target, sequence, backend, alternates, maxMessages, null);
- }
-
- @Override
- protected ClientIdentifier readTarget(final DataInput in) throws IOException {
- return ClientIdentifier.readFrom(in);
}
}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
* Request to create a new local history.
*/
public final class CreateLocalHistoryRequest extends LocalHistoryRequest<CreateLocalHistoryRequest> {
- @Serial
+ interface SerialForm extends LocalHistoryRequest.SerialForm<CreateLocalHistoryRequest> {
+ @Override
+ default CreateLocalHistoryRequest readExternal(final ObjectInput in, final LocalHistoryIdentifier target,
+ final long sequence, final ActorRef replyTo) {
+ return new CreateLocalHistoryRequest(target, sequence, replyTo);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public CreateLocalHistoryRequest(final LocalHistoryIdentifier target, final ActorRef replyTo) {
}
@Override
- protected AbstractLocalHistoryRequestProxy<CreateLocalHistoryRequest> externalizableProxy(
- final ABIVersion version) {
- return new CreateLocalHistoryRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new CHR(this) : new CreateLocalHistoryRequestProxyV1(this);
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
-
/**
* Externalizable proxy for use with {@link CreateLocalHistoryRequest}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class CreateLocalHistoryRequestProxyV1 extends AbstractLocalHistoryRequestProxy<CreateLocalHistoryRequest> {
- @Serial
+final class CreateLocalHistoryRequestProxyV1 extends AbstractLocalHistoryRequestProxy<CreateLocalHistoryRequest>
+ implements CreateLocalHistoryRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
CreateLocalHistoryRequestProxyV1(final CreateLocalHistoryRequest request) {
super(request);
}
-
- @Override
- protected CreateLocalHistoryRequest createRequest(final LocalHistoryIdentifier target, final long sequence,
- final ActorRef replyTo) {
- return new CreateLocalHistoryRequest(target, sequence, replyTo);
- }
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link DestroyLocalHistoryRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class DHR implements DestroyLocalHistoryRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private DestroyLocalHistoryRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public DHR() {
+ // for Externalizable
+ }
+
+ DHR(final DestroyLocalHistoryRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public DestroyLocalHistoryRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final DestroyLocalHistoryRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
import com.google.common.collect.RangeSet;
import com.google.common.primitives.UnsignedLong;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
/**
* been retired.
*/
public final class DeadHistoryException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public DeadHistoryException(final RangeSet<UnsignedLong> purgedHistories) {
import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.RangeSet;
import com.google.common.primitives.UnsignedLong;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
/**
* already been purged.
*/
public final class DeadTransactionException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final RangeSet<UnsignedLong> purgedIdentifiers;
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
* Request to destroy a local history.
*/
public final class DestroyLocalHistoryRequest extends LocalHistoryRequest<DestroyLocalHistoryRequest> {
- @Serial
+ interface SerialForm extends LocalHistoryRequest.SerialForm<DestroyLocalHistoryRequest> {
+ @Override
+ default DestroyLocalHistoryRequest readExternal(final ObjectInput in, final LocalHistoryIdentifier target,
+ final long sequence, final ActorRef replyTo) {
+ return new DestroyLocalHistoryRequest(target, sequence, replyTo);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public DestroyLocalHistoryRequest(final LocalHistoryIdentifier target, final long sequence,
}
@Override
- protected AbstractLocalHistoryRequestProxy<DestroyLocalHistoryRequest> externalizableProxy(
- final ABIVersion version) {
- return new DestroyLocalHistoryRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new DHR(this) : new DestroyLocalHistoryRequestProxyV1(this);
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
-
/**
* Externalizable proxy for use with {@link DestroyLocalHistoryRequest}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class DestroyLocalHistoryRequestProxyV1 extends AbstractLocalHistoryRequestProxy<DestroyLocalHistoryRequest> {
- @Serial
+final class DestroyLocalHistoryRequestProxyV1 extends AbstractLocalHistoryRequestProxy<DestroyLocalHistoryRequest>
+ implements DestroyLocalHistoryRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
DestroyLocalHistoryRequestProxyV1(final DestroyLocalHistoryRequest request) {
super(request);
}
-
- @Override
- protected DestroyLocalHistoryRequest createRequest(final LocalHistoryIdentifier target, final long sequence,
- final ActorRef replyTo) {
- return new DestroyLocalHistoryRequest(target, sequence, replyTo);
- }
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link ExistsTransactionRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class ETR implements ExistsTransactionRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ExistsTransactionRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public ETR() {
+ // for Externalizable
+ }
+
+ ETR(final ExistsTransactionRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public ExistsTransactionRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final ExistsTransactionRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link ExistsTransactionSuccess}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class ETS implements ExistsTransactionSuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ExistsTransactionSuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public ETS() {
+ // for Externalizable
+ }
+
+ ETS(final ExistsTransactionSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public ExistsTransactionSuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final ExistsTransactionSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* A transaction request to query if a particular path exists in the current view of a particular transaction.
*/
public final class ExistsTransactionRequest extends AbstractReadPathTransactionRequest<ExistsTransactionRequest> {
- @Serial
+ interface SerialForm extends AbstractReadPathTransactionRequest.SerialForm<ExistsTransactionRequest> {
+ @Override
+ default ExistsTransactionRequest readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence, final ActorRef replyTo, final boolean snapshotOnly, final YangInstanceIdentifier path)
+ throws IOException {
+ return new ExistsTransactionRequest(target, sequence, replyTo, path, snapshotOnly);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public ExistsTransactionRequest(final @NonNull TransactionIdentifier identifier, final long sequence,
- final @NonNull ActorRef replyTo, final @NonNull YangInstanceIdentifier path, final boolean snapshotOnly) {
+ final @NonNull ActorRef replyTo, final @NonNull YangInstanceIdentifier path, final boolean snapshotOnly) {
super(identifier, sequence, replyTo, path, snapshotOnly);
}
}
@Override
- protected ExistsTransactionRequestProxyV1 externalizableProxy(final ABIVersion version) {
- return new ExistsTransactionRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new ETR(this) : new ExistsTransactionRequestProxyV1(this);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-
/**
* Externalizable proxy for use with {@link ExistsTransactionRequest}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class ExistsTransactionRequestProxyV1 extends
- AbstractReadPathTransactionRequestProxyV1<ExistsTransactionRequest> {
- @Serial
+final class ExistsTransactionRequestProxyV1 extends AbstractReadPathTransactionRequestProxyV1<ExistsTransactionRequest>
+ implements ExistsTransactionRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
ExistsTransactionRequestProxyV1(final ExistsTransactionRequest request) {
super(request);
}
-
- @Override
- ExistsTransactionRequest createReadPathRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyTo, final YangInstanceIdentifier path, final boolean snapshotOnly) {
- return new ExistsTransactionRequest(target, sequence, replyTo, path, snapshotOnly);
- }
}
package org.opendaylight.controller.cluster.access.commands;
import com.google.common.base.MoreObjects.ToStringHelper;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* {@link #getExists()}.
*/
public final class ExistsTransactionSuccess extends TransactionSuccess<ExistsTransactionSuccess> {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<ExistsTransactionSuccess> {
+ @Override
+ default ExistsTransactionSuccess readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence) throws IOException {
+ return new ExistsTransactionSuccess(target, sequence, in.readBoolean());
+ }
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final ExistsTransactionSuccess msg) throws IOException {
+ out.writeBoolean(msg.getExists());
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final boolean exists;
+ private ExistsTransactionSuccess(final ExistsTransactionSuccess success, final ABIVersion version) {
+ super(success, version);
+ exists = success.exists;
+ }
+
public ExistsTransactionSuccess(final TransactionIdentifier target, final long sequence, final boolean exists) {
super(target, sequence);
this.exists = exists;
}
@Override
- protected ExistsTransactionSuccessProxyV1 externalizableProxy(final ABIVersion version) {
- return new ExistsTransactionSuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new ETS(this) : new ExistsTransactionSuccessProxyV1(this);
}
@Override
protected ExistsTransactionSuccess cloneAsVersion(final ABIVersion version) {
- return this;
+ return new ExistsTransactionSuccess(this, version);
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link ExistsTransactionSuccess}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class ExistsTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ExistsTransactionSuccess> {
- @Serial
+final class ExistsTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ExistsTransactionSuccess>
+ implements ExistsTransactionSuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private boolean exists;
-
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
@SuppressWarnings("checkstyle:RedundantModifier")
ExistsTransactionSuccessProxyV1(final ExistsTransactionSuccess request) {
super(request);
- exists = request.getExists();
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
- out.writeBoolean(exists);
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
- exists = in.readBoolean();
- }
-
- @Override
- protected ExistsTransactionSuccess createSuccess(final TransactionIdentifier target, final long sequence) {
- return new ExistsTransactionSuccess(target, sequence, exists);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link LocalHistoryFailure}. It implements the Chlorine SR2 serialization format.
+ */
+final class HF implements LocalHistoryFailure.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private LocalHistoryFailure message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public HF() {
+ // for Externalizable
+ }
+
+ HF(final LocalHistoryFailure message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public LocalHistoryFailure message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final LocalHistoryFailure message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link LocalHistorySuccess}. It implements the Chlorine SR2 serialization format.
+ */
+final class HS implements LocalHistorySuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private LocalHistorySuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public HS() {
+ // for Externalizable
+ }
+
+ HS(final LocalHistorySuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public LocalHistorySuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final LocalHistorySuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link IncrementTransactionSequenceRequest}. It implements the Chlorine SR2
+ * serialization format.
+ */
+final class ITSR implements IncrementTransactionSequenceRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private IncrementTransactionSequenceRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public ITSR() {
+ // for Externalizable
+ }
+
+ ITSR(final IncrementTransactionSequenceRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public IncrementTransactionSequenceRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final IncrementTransactionSequenceRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link IncrementTransactionSequenceSuccess}. It implements the Chlorine SR2
+ * serialization format.
+ */
+final class ITSS implements IncrementTransactionSequenceSuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private IncrementTransactionSequenceSuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public ITSS() {
+ // for Externalizable
+ }
+
+ ITSS(final IncrementTransactionSequenceSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public IncrementTransactionSequenceSuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final IncrementTransactionSequenceSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
*/
package org.opendaylight.controller.cluster.access.commands;
+import static com.google.common.base.Preconditions.checkArgument;
+
import akka.actor.ActorRef;
-import com.google.common.base.Preconditions;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
+import org.opendaylight.yangtools.concepts.WritableObjects;
/**
* A blank transaction request. This is used to provide backfill requests in converted retransmit scenarios, such as
* when a initial request to a transaction (such as a {@link ReadTransactionRequest}) is satisfied by the backend
* before the need to replay the transaction to a different remote backend.
- *
- * @author Robert Varga
*/
public final class IncrementTransactionSequenceRequest extends
AbstractReadTransactionRequest<IncrementTransactionSequenceRequest> {
- @Serial
+ interface SerialForm extends AbstractReadTransactionRequest.SerialForm<IncrementTransactionSequenceRequest> {
+ @Override
+ default void writeExternal(final ObjectOutput out, final IncrementTransactionSequenceRequest msg)
+ throws IOException {
+ AbstractReadTransactionRequest.SerialForm.super.writeExternal(out, msg);
+ WritableObjects.writeLong(out, msg.getIncrement());
+ }
+
+ @Override
+ default IncrementTransactionSequenceRequest readExternal(final ObjectInput in,
+ final TransactionIdentifier target, final long sequence, final ActorRef replyTo,
+ final boolean snapshotOnly) throws IOException {
+ return new IncrementTransactionSequenceRequest(target, sequence, replyTo, snapshotOnly,
+ WritableObjects.readLong(in));
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final long increment;
+ public IncrementTransactionSequenceRequest(final IncrementTransactionSequenceRequest request,
+ final ABIVersion version) {
+ super(request, version);
+ increment = request.increment;
+ }
+
public IncrementTransactionSequenceRequest(final TransactionIdentifier identifier, final long sequence,
final ActorRef replyTo, final boolean snapshotOnly, final long increment) {
super(identifier, sequence, replyTo, snapshotOnly);
- Preconditions.checkArgument(increment >= 0);
+ checkArgument(increment >= 0, "Unexpected increment %s", increment);
this.increment = increment;
}
}
@Override
- protected IncrementTransactionSequenceRequestProxyV1 externalizableProxy(final ABIVersion version) {
- return new IncrementTransactionSequenceRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new ITSR(this) : new IncrementTransactionSequenceRequestProxyV1(this);
}
@Override
protected IncrementTransactionSequenceRequest cloneAsVersion(final ABIVersion targetVersion) {
- return this;
+ return new IncrementTransactionSequenceRequest(this, targetVersion);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.yangtools.concepts.WritableObjects;
-
final class IncrementTransactionSequenceRequestProxyV1
- extends AbstractReadTransactionRequestProxyV1<IncrementTransactionSequenceRequest> {
- @Serial
+ extends AbstractReadTransactionRequestProxyV1<IncrementTransactionSequenceRequest>
+ implements IncrementTransactionSequenceRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = -7345885599575376005L;
- private long increment;
-
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
@SuppressWarnings("checkstyle:RedundantModifier")
IncrementTransactionSequenceRequestProxyV1(final IncrementTransactionSequenceRequest request) {
super(request);
- increment = request.getIncrement();
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
- WritableObjects.writeLong(out, increment);
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws ClassNotFoundException, IOException {
- super.readExternal(in);
- increment = WritableObjects.readLong(in);
- }
-
- @Override
- IncrementTransactionSequenceRequest createReadRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyToActor, final boolean snapshotOnly) {
- return new IncrementTransactionSequenceRequest(target, sequence, replyToActor, snapshotOnly, increment);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* Successful reply to an {@link IncrementTransactionSequenceRequest}.
*/
public final class IncrementTransactionSequenceSuccess extends TransactionSuccess<IncrementTransactionSequenceSuccess> {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<IncrementTransactionSequenceSuccess> {
+ @Override
+ default IncrementTransactionSequenceSuccess readExternal(final ObjectInput it,
+ final TransactionIdentifier target, final long sequence) {
+ return new IncrementTransactionSequenceSuccess(target, sequence);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private IncrementTransactionSequenceSuccess(final IncrementTransactionSequenceSuccess success,
+ final ABIVersion version) {
+ super(success, version);
+ }
+
public IncrementTransactionSequenceSuccess(final TransactionIdentifier target, final long sequence) {
super(target, sequence);
}
@Override
- protected IncrementTransactionSequenceSuccessProxyV1 externalizableProxy(final ABIVersion version) {
- return new IncrementTransactionSequenceSuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new ITSS(this) : new IncrementTransactionSequenceSuccessProxyV1(this);
}
@Override
protected IncrementTransactionSequenceSuccess cloneAsVersion(final ABIVersion version) {
- return this;
+ return new IncrementTransactionSequenceSuccess(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link IncrementTransactionSequenceSuccess}. It implements the initial (Boron)
* serialization format.
* @author Robert Varga
*/
final class IncrementTransactionSequenceSuccessProxyV1
- extends AbstractTransactionSuccessProxy<IncrementTransactionSequenceSuccess> {
- @Serial
+ extends AbstractTransactionSuccessProxy<IncrementTransactionSequenceSuccess>
+ implements IncrementTransactionSequenceSuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
IncrementTransactionSequenceSuccessProxyV1(final IncrementTransactionSequenceSuccess request) {
super(request);
}
-
- @Override
- protected IncrementTransactionSequenceSuccess createSuccess(final TransactionIdentifier target,
- final long sequence) {
- return new IncrementTransactionSequenceSuccess(target, sequence);
- }
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.IOException;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
* Generic {@link RequestFailure} involving a {@link LocalHistoryRequest}.
*/
public final class LocalHistoryFailure extends RequestFailure<LocalHistoryIdentifier, LocalHistoryFailure> {
- @Serial
+ interface SerialForm extends RequestFailure.SerialForm<LocalHistoryIdentifier, LocalHistoryFailure> {
+ @Override
+ default LocalHistoryIdentifier readTarget(final DataInput in) throws IOException {
+ return LocalHistoryIdentifier.readFrom(in);
+ }
+
+ @Override
+ default LocalHistoryFailure createFailure(final LocalHistoryIdentifier target, final long sequence,
+ final RequestException cause) {
+ return new LocalHistoryFailure(target, sequence, cause);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private LocalHistoryFailure(final LocalHistoryFailure failure, final ABIVersion version) {
+ super(failure, version);
+ }
+
LocalHistoryFailure(final LocalHistoryIdentifier target, final long sequence, final RequestException cause) {
super(target, sequence, cause);
}
@Override
- protected LocalHistoryFailure cloneAsVersion(final ABIVersion version) {
- return this;
+ protected LocalHistoryFailure cloneAsVersion(final ABIVersion targetVersion) {
+ return new LocalHistoryFailure(this, targetVersion);
}
@Override
- protected LocalHistoryFailureProxyV1 externalizableProxy(final ABIVersion version) {
- return new LocalHistoryFailureProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new HF(this) : new LocalHistoryFailureProxyV1(this);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.DataInput;
-import java.io.IOException;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestFailureProxy;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
-import org.opendaylight.controller.cluster.access.concepts.RequestException;
/**
* Externalizable proxy for use with {@link LocalHistoryFailure}. It implements the initial (Boron) serialization
*
* @author Robert Varga
*/
-final class LocalHistoryFailureProxyV1 extends
- AbstractRequestFailureProxy<LocalHistoryIdentifier, LocalHistoryFailure> {
- @Serial
+final class LocalHistoryFailureProxyV1
+ extends AbstractRequestFailureProxy<LocalHistoryIdentifier, LocalHistoryFailure>
+ implements LocalHistoryFailure.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
LocalHistoryFailureProxyV1(final LocalHistoryFailure failure) {
super(failure);
}
-
- @Override
- protected LocalHistoryFailure createFailure(final LocalHistoryIdentifier target, final long sequence,
- final RequestException cause) {
- return new LocalHistoryFailure(target, sequence, cause);
- }
-
- @Override
- protected LocalHistoryIdentifier readTarget(final DataInput in) throws IOException {
- return LocalHistoryIdentifier.readFrom(in);
- }
}
import akka.actor.ActorRef;
import com.google.common.base.Preconditions;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.IOException;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
import org.opendaylight.controller.cluster.access.concepts.Request;
* @param <T> Message type
*/
public abstract class LocalHistoryRequest<T extends LocalHistoryRequest<T>> extends Request<LocalHistoryIdentifier, T> {
- @Serial
+ interface SerialForm<T extends LocalHistoryRequest<T>> extends Request.SerialForm<LocalHistoryIdentifier, T> {
+ @Override
+ default LocalHistoryIdentifier readTarget(final DataInput in) throws IOException {
+ return LocalHistoryIdentifier.readFrom(in);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
LocalHistoryRequest(final LocalHistoryIdentifier target, final long sequence, final ActorRef replyTo) {
}
@Override
- protected abstract AbstractLocalHistoryRequestProxy<T> externalizableProxy(ABIVersion version);
+ protected abstract SerialForm<T> externalizableProxy(ABIVersion version);
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.IOException;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
-import org.opendaylight.controller.cluster.access.concepts.AbstractSuccessProxy;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
import org.opendaylight.controller.cluster.access.concepts.RequestSuccess;
* Success class for {@link RequestSuccess}es involving a specific local history.
*/
public final class LocalHistorySuccess extends RequestSuccess<LocalHistoryIdentifier, LocalHistorySuccess> {
- @Serial
- private static final long serialVersionUID = 1L;
+ interface SerialForm extends RequestSuccess.SerialForm<LocalHistoryIdentifier, LocalHistorySuccess> {
+ @Override
+ default LocalHistoryIdentifier readTarget(final DataInput in) throws IOException {
+ return LocalHistoryIdentifier.readFrom(in);
+ }
- public LocalHistorySuccess(final LocalHistoryIdentifier target, final long sequence) {
- super(target, sequence);
+ @Override
+ default LocalHistorySuccess readExternal(final ObjectInput it, final LocalHistoryIdentifier target,
+ final long sequence) {
+ return new LocalHistorySuccess(target, sequence);
+ }
}
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
private LocalHistorySuccess(final LocalHistorySuccess success, final ABIVersion version) {
super(success, version);
}
+ public LocalHistorySuccess(final LocalHistoryIdentifier target, final long sequence) {
+ super(target, sequence);
+ }
+
@Override
protected LocalHistorySuccess cloneAsVersion(final ABIVersion version) {
return new LocalHistorySuccess(this, version);
}
@Override
- protected AbstractSuccessProxy<LocalHistoryIdentifier, LocalHistorySuccess> externalizableProxy(
- final ABIVersion version) {
- return new LocalHistorySuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new HS(this) : new LocalHistorySuccessProxyV1(this);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.DataInput;
-import java.io.IOException;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractSuccessProxy;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
*
* @author Robert Varga
*/
-final class LocalHistorySuccessProxyV1 extends AbstractSuccessProxy<LocalHistoryIdentifier, LocalHistorySuccess> {
- @Serial
+final class LocalHistorySuccessProxyV1 extends AbstractSuccessProxy<LocalHistoryIdentifier, LocalHistorySuccess>
+ implements LocalHistorySuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
LocalHistorySuccessProxyV1(final LocalHistorySuccess success) {
super(success);
}
-
- @Override
- protected LocalHistoryIdentifier readTarget(final DataInput in) throws IOException {
- return LocalHistoryIdentifier.readFrom(in);
- }
-
- @Override
- protected LocalHistorySuccess createSuccess(final LocalHistoryIdentifier target, final long sequence) {
- return new LocalHistorySuccess(target, sequence);
- }
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link ModifyTransactionRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class MTR implements ModifyTransactionRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ModifyTransactionRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public MTR() {
+ // for Externalizable
+ }
+
+ MTR(final ModifyTransactionRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public ModifyTransactionRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final ModifyTransactionRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link ModifyTransactionSuccess}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class MTS implements ModifyTransactionSuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ModifyTransactionSuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public MTS() {
+ // for Externalizable
+ }
+
+ MTS(final ModifyTransactionSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public ModifyTransactionSuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final ModifyTransactionSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.collect.ImmutableList;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.SliceableMessage;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
+import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput;
+import org.opendaylight.yangtools.yang.data.impl.schema.ReusableImmutableNormalizedNodeStreamWriter;
/**
* A transaction request to apply a particular set of operations on top of the current transaction. This message is
*/
public final class ModifyTransactionRequest extends TransactionRequest<ModifyTransactionRequest>
implements SliceableMessage {
- @Serial
+ interface SerialForm extends TransactionRequest.SerialForm<ModifyTransactionRequest> {
+
+
+ @Override
+ default ModifyTransactionRequest readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence, final ActorRef replyTo) throws IOException {
+
+ final var protocol = Optional.ofNullable(PersistenceProtocol.readFrom(in));
+ final int size = in.readInt();
+ final List<TransactionModification> modifications;
+ if (size != 0) {
+ modifications = new ArrayList<>(size);
+ final var nnin = NormalizedNodeDataInput.newDataInput(in);
+ final var writer = ReusableImmutableNormalizedNodeStreamWriter.create();
+ for (int i = 0; i < size; ++i) {
+ modifications.add(TransactionModification.readFrom(nnin, writer));
+ }
+ } else {
+ modifications = ImmutableList.of();
+ }
+
+ return new ModifyTransactionRequest(target, sequence, replyTo, modifications, protocol.orElse(null));
+ }
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final ModifyTransactionRequest msg) throws IOException {
+ TransactionRequest.SerialForm.super.writeExternal(out, msg);
+
+ out.writeByte(PersistenceProtocol.byteValue(msg.getPersistenceProtocol().orElse(null)));
+
+ final var modifications = msg.getModifications();
+ out.writeInt(modifications.size());
+ if (!modifications.isEmpty()) {
+ try (var nnout = msg.getVersion().getStreamVersion().newDataOutput(out)) {
+ for (var op : modifications) {
+ op.writeTo(nnout);
+ }
+ }
+ }
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
@SuppressFBWarnings(value = "SE_BAD_FIELD", justification = "This field is not Serializable but this class "
private final List<TransactionModification> modifications;
private final PersistenceProtocol protocol;
+ private ModifyTransactionRequest(final ModifyTransactionRequest request, final ABIVersion version) {
+ super(request, version);
+ modifications = request.modifications;
+ protocol = request.protocol;
+ }
+
ModifyTransactionRequest(final TransactionIdentifier target, final long sequence, final ActorRef replyTo,
final List<TransactionModification> modifications, final PersistenceProtocol protocol) {
super(target, sequence, replyTo);
}
@Override
- protected ModifyTransactionRequestProxyV1 externalizableProxy(final ABIVersion version) {
- return new ModifyTransactionRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new MTR(this) : new ModifyTransactionRequestProxyV1(this);
}
@Override
protected ModifyTransactionRequest cloneAsVersion(final ABIVersion version) {
- return this;
+ return new ModifyTransactionRequest(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import static java.util.Objects.requireNonNull;
-
-import akka.actor.ActorRef;
-import com.google.common.collect.ImmutableList;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput;
-import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataOutput;
-import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion;
-import org.opendaylight.yangtools.yang.data.impl.schema.ReusableImmutableNormalizedNodeStreamWriter;
-
/**
* Externalizable proxy for use with {@link ExistsTransactionRequest}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class ModifyTransactionRequestProxyV1 extends AbstractTransactionRequestProxy<ModifyTransactionRequest> {
- @Serial
+final class ModifyTransactionRequestProxyV1 extends AbstractTransactionRequestProxy<ModifyTransactionRequest>
+ implements ModifyTransactionRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private List<TransactionModification> modifications;
- private Optional<PersistenceProtocol> protocol;
- private transient NormalizedNodeStreamVersion streamVersion;
-
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
@SuppressWarnings("checkstyle:RedundantModifier")
ModifyTransactionRequestProxyV1(final ModifyTransactionRequest request) {
super(request);
- modifications = requireNonNull(request.getModifications());
- protocol = request.getPersistenceProtocol();
- streamVersion = request.getVersion().getStreamVersion();
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- protocol = Optional.ofNullable(PersistenceProtocol.readFrom(in));
-
- final int size = in.readInt();
- if (size != 0) {
- modifications = new ArrayList<>(size);
- final NormalizedNodeDataInput nnin = NormalizedNodeDataInput.newDataInput(in);
- final ReusableImmutableNormalizedNodeStreamWriter writer =
- ReusableImmutableNormalizedNodeStreamWriter.create();
- for (int i = 0; i < size; ++i) {
- modifications.add(TransactionModification.readFrom(nnin, writer));
- }
- } else {
- modifications = ImmutableList.of();
- }
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- out.writeByte(PersistenceProtocol.byteValue(protocol.orElse(null)));
- out.writeInt(modifications.size());
- if (!modifications.isEmpty()) {
- try (NormalizedNodeDataOutput nnout = streamVersion.newDataOutput(out)) {
- for (TransactionModification op : modifications) {
- op.writeTo(nnout);
- }
- }
- }
- }
-
- @Override
- protected ModifyTransactionRequest createRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyTo) {
- return new ModifyTransactionRequest(target, sequence, replyTo, modifications, protocol.orElse(null));
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* Response to a {@link ModifyTransactionRequest} which does not have a {@link PersistenceProtocol}.
*/
public final class ModifyTransactionSuccess extends TransactionSuccess<ModifyTransactionSuccess> {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<ModifyTransactionSuccess> {
+ @Override
+ default ModifyTransactionSuccess readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence) throws IOException {
+ return new ModifyTransactionSuccess(target, sequence);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public ModifyTransactionSuccess(final TransactionIdentifier identifier, final long sequence) {
}
@Override
- protected AbstractTransactionSuccessProxy<ModifyTransactionSuccess> externalizableProxy(final ABIVersion version) {
- return new ModifyTransactionSuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new MTS(this) : new ModifyTransactionSuccessProxyV1(this);
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link ModifyTransactionSuccess}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class ModifyTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ModifyTransactionSuccess> {
- @Serial
+final class ModifyTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ModifyTransactionSuccess>
+ implements ModifyTransactionSuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
ModifyTransactionSuccessProxyV1(final ModifyTransactionSuccess success) {
super(success);
}
-
- @Override
- protected ModifyTransactionSuccess createSuccess(final TransactionIdentifier target, final long sequence) {
- return new ModifyTransactionSuccess(target, sequence);
- }
}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
/**
* means that the backend processing has moved and the frontend needs to run rediscovery and retry the request.
*/
public final class NotLeaderException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public NotLeaderException(final ActorRef me) {
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
/**
* next expected sequence for the target. This is a hard error, as it indicates a Request is missing in the stream.
*/
public final class OutOfOrderRequestException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public OutOfOrderRequestException(final long expectedRequest) {
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
/**
* the backend is not the leader and it transitions to being a leader with old stream messages still being present.
*/
public final class OutOfSequenceEnvelopeException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public OutOfSequenceEnvelopeException(final long expectedEnvelope) {
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link PurgeLocalHistoryRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class PHR implements PurgeLocalHistoryRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private PurgeLocalHistoryRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public PHR() {
+ // for Externalizable
+ }
+
+ PHR(final PurgeLocalHistoryRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public PurgeLocalHistoryRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final PurgeLocalHistoryRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
* {@link DestroyLocalHistoryRequest} and indicates it has removed all state attached to a particular local history.
*/
public final class PurgeLocalHistoryRequest extends LocalHistoryRequest<PurgeLocalHistoryRequest> {
- @Serial
+ interface SerialForm extends LocalHistoryRequest.SerialForm<PurgeLocalHistoryRequest> {
+ @Override
+ default PurgeLocalHistoryRequest readExternal(final ObjectInput in, final LocalHistoryIdentifier target,
+ final long sequence, final ActorRef replyTo) {
+ return new PurgeLocalHistoryRequest(target, sequence, replyTo);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public PurgeLocalHistoryRequest(final LocalHistoryIdentifier target, final long sequence, final ActorRef replyTo) {
}
@Override
- protected AbstractLocalHistoryRequestProxy<PurgeLocalHistoryRequest> externalizableProxy(final ABIVersion version) {
- return new PurgeLocalHistoryRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new PHR(this) : new PurgeLocalHistoryRequestProxyV1(this);
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
-
/**
* Externalizable proxy for use with {@link PurgeLocalHistoryRequest}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class PurgeLocalHistoryRequestProxyV1 extends AbstractLocalHistoryRequestProxy<PurgeLocalHistoryRequest> {
- @Serial
+final class PurgeLocalHistoryRequestProxyV1 extends AbstractLocalHistoryRequestProxy<PurgeLocalHistoryRequest>
+ implements PurgeLocalHistoryRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
PurgeLocalHistoryRequestProxyV1(final PurgeLocalHistoryRequest request) {
super(request);
}
-
- @Override
- protected PurgeLocalHistoryRequest createRequest(final LocalHistoryIdentifier target, final long sequence,
- final ActorRef replyTo) {
- return new PurgeLocalHistoryRequest(target, sequence, replyTo);
- }
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link ReadTransactionRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class RTR implements ReadTransactionRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ReadTransactionRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public RTR() {
+ // for Externalizable
+ }
+
+ RTR(final ReadTransactionRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public ReadTransactionRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final ReadTransactionRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link ReadTransactionSuccess}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class RTS implements ReadTransactionSuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ReadTransactionSuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public RTS() {
+ // for Externalizable
+ }
+
+ RTS(final ReadTransactionSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public ReadTransactionSuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final ReadTransactionSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* A transaction request to read a particular path exists in the current view of a particular transaction.
*/
public final class ReadTransactionRequest extends AbstractReadPathTransactionRequest<ReadTransactionRequest> {
- @Serial
+ interface SerialForm extends AbstractReadPathTransactionRequest.SerialForm<ReadTransactionRequest> {
+ @Override
+ default ReadTransactionRequest readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence, final ActorRef replyTo, final boolean snapshotOnly, final YangInstanceIdentifier path)
+ throws IOException {
+ return new ReadTransactionRequest(target, sequence, replyTo, path, snapshotOnly);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public ReadTransactionRequest(final @NonNull TransactionIdentifier identifier, final long sequence,
}
@Override
- protected ReadTransactionRequestProxyV1 externalizableProxy(final ABIVersion version) {
- return new ReadTransactionRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new RTR(this) : new ReadTransactionRequestProxyV1(this);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-
/**
* Externalizable proxy for use with {@link ReadTransactionRequest}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class ReadTransactionRequestProxyV1 extends AbstractReadPathTransactionRequestProxyV1<ReadTransactionRequest> {
- @Serial
+final class ReadTransactionRequestProxyV1 extends AbstractReadPathTransactionRequestProxyV1<ReadTransactionRequest>
+ implements ReadTransactionRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
ReadTransactionRequestProxyV1(final ReadTransactionRequest request) {
super(request);
}
-
- @Override
- ReadTransactionRequest createReadPathRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyTo, final YangInstanceIdentifier path, final boolean snapshotOnly) {
- return new ReadTransactionRequest(target, sequence, replyTo, path, snapshotOnly);
- }
}
import static java.util.Objects.requireNonNull;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import java.util.Optional;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.SliceableMessage;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput;
/**
* Successful reply to an {@link ReadTransactionRequest}. It indicates presence of requested data via
*/
public final class ReadTransactionSuccess extends TransactionSuccess<ReadTransactionSuccess>
implements SliceableMessage {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<ReadTransactionSuccess> {
+ @Override
+ default ReadTransactionSuccess readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence) throws IOException {
+ final Optional<NormalizedNode> data;
+ if (in.readBoolean()) {
+ data = Optional.of(NormalizedNodeDataInput.newDataInput(in).readNormalizedNode());
+ } else {
+ data = Optional.empty();
+ }
+ return new ReadTransactionSuccess(target, sequence, data);
+ }
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final ReadTransactionSuccess msg) throws IOException {
+ TransactionSuccess.SerialForm.super.writeExternal(out, msg);
+
+ final var data = msg.getData();
+ if (data.isPresent()) {
+ out.writeBoolean(true);
+ try (var nnout = msg.getVersion().getStreamVersion().newDataOutput(out)) {
+ nnout.writeNormalizedNode(data.orElseThrow());
+ }
+ } else {
+ out.writeBoolean(false);
+ }
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
@SuppressFBWarnings(value = "SE_BAD_FIELD", justification = "interface-based best effort")
private final Optional<NormalizedNode> data;
+ private ReadTransactionSuccess(final ReadTransactionSuccess request, final ABIVersion version) {
+ super(request, version);
+ data = request.data;
+ }
+
public ReadTransactionSuccess(final TransactionIdentifier identifier, final long sequence,
final Optional<NormalizedNode> data) {
super(identifier, sequence);
}
@Override
- protected AbstractTransactionSuccessProxy<ReadTransactionSuccess> externalizableProxy(final ABIVersion version) {
- return new ReadTransactionSuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new RTS(this) : new ReadTransactionSuccessProxyV1(this);
}
@Override
protected ReadTransactionSuccess cloneAsVersion(final ABIVersion version) {
- return this;
+ return new ReadTransactionSuccess(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import java.util.Optional;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-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.NormalizedNodeDataOutput;
-import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion;
-
/**
* Externalizable proxy for use with {@link ReadTransactionSuccess}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class ReadTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ReadTransactionSuccess> {
- @Serial
+final class ReadTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ReadTransactionSuccess>
+ implements ReadTransactionSuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private Optional<NormalizedNode> data;
- private transient NormalizedNodeStreamVersion streamVersion;
-
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
@SuppressWarnings("checkstyle:RedundantModifier")
ReadTransactionSuccessProxyV1(final ReadTransactionSuccess request) {
super(request);
- data = request.getData();
- streamVersion = request.getVersion().getStreamVersion();
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- if (data.isPresent()) {
- out.writeBoolean(true);
- try (NormalizedNodeDataOutput nnout = streamVersion.newDataOutput(out)) {
- nnout.writeNormalizedNode(data.get());
- }
- } else {
- out.writeBoolean(false);
- }
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- if (in.readBoolean()) {
- data = Optional.of(NormalizedNodeDataInput.newDataInput(in).readNormalizedNode());
- } else {
- data = Optional.empty();
- }
- }
-
- @Override
- protected ReadTransactionSuccess createSuccess(final TransactionIdentifier target, final long sequence) {
- return new ReadTransactionSuccess(target, sequence, data);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link SkipTransactionsRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class STR implements SkipTransactionsRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private SkipTransactionsRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public STR() {
+ // for Externalizable
+ }
+
+ STR(final SkipTransactionsRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public SkipTransactionsRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final SkipTransactionsRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link SkipTransactionsResponse}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class STS implements SkipTransactionsResponse.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private SkipTransactionsResponse message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public STS() {
+ // for Externalizable
+ }
+
+ STS(final SkipTransactionsResponse message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public SkipTransactionsResponse message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final SkipTransactionsResponse message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.collect.ImmutableList;
import com.google.common.primitives.UnsignedLong;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import java.util.Collection;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
+import org.opendaylight.yangtools.concepts.WritableObjects;
/**
* Request to skip a number of {@link TransactionIdentifier}s within a {code local history}. This request is essentially
* explicitly retired and are guaranteed to never be used by the frontend.
*/
public final class SkipTransactionsRequest extends TransactionRequest<SkipTransactionsRequest> {
- @Serial
+ interface SerialForm extends TransactionRequest.SerialForm<SkipTransactionsRequest> {
+ @Override
+ default SkipTransactionsRequest readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence, final ActorRef replyTo) throws IOException {
+ final int size = in.readInt();
+ final var builder = ImmutableList.<UnsignedLong>builderWithExpectedSize(size);
+ int idx;
+ if (size % 2 != 0) {
+ builder.add(UnsignedLong.fromLongBits(WritableObjects.readLong(in)));
+ idx = 1;
+ } else {
+ idx = 0;
+ }
+ for (; idx < size; idx += 2) {
+ final byte hdr = WritableObjects.readLongHeader(in);
+ builder.add(UnsignedLong.fromLongBits(WritableObjects.readFirstLong(in, hdr)));
+ builder.add(UnsignedLong.fromLongBits(WritableObjects.readSecondLong(in, hdr)));
+ }
+
+ return new SkipTransactionsRequest(target, sequence, replyTo, builder.build());
+ }
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final SkipTransactionsRequest msg) throws IOException {
+ TransactionRequest.SerialForm.super.writeExternal(out, msg);
+
+ final var others = msg.others;
+ final int size = others.size();
+ out.writeInt(size);
+
+ int idx;
+ if (size % 2 != 0) {
+ WritableObjects.writeLong(out, others.get(0).longValue());
+ idx = 1;
+ } else {
+ idx = 0;
+ }
+ for (; idx < size; idx += 2) {
+ WritableObjects.writeLongs(out, others.get(idx).longValue(), others.get(idx + 1).longValue());
+ }
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// Note: UnsignedLong is arbitrary, yang.common.Uint64 would work just as well, we really want an immutable
this.others = ImmutableList.copyOf(others);
}
+ private SkipTransactionsRequest(final SkipTransactionsRequest request, final ABIVersion version) {
+ super(request, version);
+ others = request.others;
+ }
+
/**
* Return this {@link #getTarget()}s sibling {@link TransactionIdentifier}s.
*
}
@Override
- protected SkipTransactionsRequestV1 externalizableProxy(final ABIVersion version) {
- return new SkipTransactionsRequestV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new STR(this) : new SkipTransactionsRequestV1(this);
}
@Override
protected SkipTransactionsRequest cloneAsVersion(final ABIVersion version) {
- return this;
+ return new SkipTransactionsRequest(this, version);
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import com.google.common.collect.ImmutableList;
-import com.google.common.primitives.UnsignedLong;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import java.util.List;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.yangtools.concepts.WritableObjects;
-
/**
* Externalizable proxy for use with {@link SkipTransactionsRequest}. It implements the initial
* (Phosphorus SR1) serialization format.
*/
-final class SkipTransactionsRequestV1 extends AbstractTransactionRequestProxy<SkipTransactionsRequest> {
- @Serial
+final class SkipTransactionsRequestV1 extends AbstractTransactionRequestProxy<SkipTransactionsRequest>
+ implements SkipTransactionsRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = -7493419007644462643L;
- private List<UnsignedLong> others;
-
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
@SuppressWarnings("checkstyle:RedundantModifier")
SkipTransactionsRequestV1(final SkipTransactionsRequest request) {
super(request);
- others = request.getOthers();
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- final int size = in.readInt();
- final var builder = ImmutableList.<UnsignedLong>builderWithExpectedSize(size);
- int idx;
- if (size % 2 != 0) {
- builder.add(UnsignedLong.fromLongBits(WritableObjects.readLong(in)));
- idx = 1;
- } else {
- idx = 0;
- }
- for (; idx < size; idx += 2) {
- final byte hdr = WritableObjects.readLongHeader(in);
- builder.add(UnsignedLong.fromLongBits(WritableObjects.readFirstLong(in, hdr)));
- builder.add(UnsignedLong.fromLongBits(WritableObjects.readSecondLong(in, hdr)));
- }
- others = builder.build();
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- final int size = others.size();
- out.writeInt(size);
-
- int idx;
- if (size % 2 != 0) {
- WritableObjects.writeLong(out, others.get(0).longValue());
- idx = 1;
- } else {
- idx = 0;
- }
- for (; idx < size; idx += 2) {
- WritableObjects.writeLongs(out, others.get(idx).longValue(), others.get(idx + 1).longValue());
- }
- }
-
- @Override
- protected SkipTransactionsRequest createRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyToActor) {
- return new SkipTransactionsRequest(target, sequence, replyToActor, others);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* Successful reply to a {@link SkipTransactionsRequest}.
*/
+// FIXME: rename to SkipTransactionsSuccess
public final class SkipTransactionsResponse extends TransactionSuccess<SkipTransactionsResponse> {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<SkipTransactionsResponse> {
+ @Override
+ default SkipTransactionsResponse readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence) {
+ return new SkipTransactionsResponse(target, sequence);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private SkipTransactionsResponse(final SkipTransactionsResponse success, final ABIVersion version) {
+ super(success, version);
+ }
+
public SkipTransactionsResponse(final TransactionIdentifier identifier, final long sequence) {
super(identifier, sequence);
}
@Override
- protected AbstractTransactionSuccessProxy<SkipTransactionsResponse> externalizableProxy(
- final ABIVersion version) {
- return new SkipTransactionsResponseProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new STS(this) : new SkipTransactionsResponseProxyV1(this);
}
@Override
protected SkipTransactionsResponse cloneAsVersion(final ABIVersion version) {
- return this;
+ return new SkipTransactionsResponse(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link SkipTransactionsResponse}. It implements the initial (Phosphorus SR1)
* serialization format.
*/
-final class SkipTransactionsResponseProxyV1 extends AbstractTransactionSuccessProxy<SkipTransactionsResponse> {
- @Serial
+final class SkipTransactionsResponseProxyV1 extends AbstractTransactionSuccessProxy<SkipTransactionsResponse>
+ implements SkipTransactionsResponse.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
SkipTransactionsResponseProxyV1(final SkipTransactionsResponse success) {
super(success);
}
-
- @Override
- protected SkipTransactionsResponse createSuccess(final TransactionIdentifier target, final long sequence) {
- return new SkipTransactionsResponse(target, sequence);
- }
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionAbortRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class TAR implements TransactionAbortRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionAbortRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TAR() {
+ // for Externalizable
+ }
+
+ TAR(final TransactionAbortRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionAbortRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionAbortRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionAbortSuccess}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class TAS implements TransactionAbortSuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionAbortSuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TAS() {
+ // for Externalizable
+ }
+
+ TAS(final TransactionAbortSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionAbortSuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionAbortSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionCanCommitSuccess}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class TCCS implements TransactionCanCommitSuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionCanCommitSuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TCCS() {
+ // for Externalizable
+ }
+
+ TCCS(final TransactionCanCommitSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionCanCommitSuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionCanCommitSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionCommitSuccess}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class TCS implements TransactionCommitSuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionCommitSuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TCS() {
+ // for Externalizable
+ }
+
+ TCS(final TransactionCommitSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionCommitSuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionCommitSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionDoCommitRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class TDCR implements TransactionDoCommitRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionDoCommitRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TDCR() {
+ // for Externalizable
+ }
+
+ TDCR(final TransactionDoCommitRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionDoCommitRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionDoCommitRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionFailure}. It implements the Chlorine SR2 serialization format.
+ */
+final class TF implements TransactionFailure.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionFailure message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TF() {
+ // for Externalizable
+ }
+
+ TF(final TransactionFailure message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionFailure message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionFailure message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionPreCommitRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class TPCR implements TransactionPreCommitRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionPreCommitRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TPCR() {
+ // for Externalizable
+ }
+
+ TPCR(final TransactionPreCommitRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionPreCommitRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionPreCommitRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionPreCommitSuccess}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class TPCS implements TransactionPreCommitSuccess.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionPreCommitSuccess message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TPCS() {
+ // for Externalizable
+ }
+
+ TPCS(final TransactionPreCommitSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionPreCommitSuccess message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionPreCommitSuccess message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionPurgeRequest}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class TPR implements TransactionPurgeRequest.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionPurgeRequest message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TPR() {
+ // for Externalizable
+ }
+
+ TPR(final TransactionPurgeRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionPurgeRequest message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionPurgeRequest message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.commands;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Externalizable proxy for use with {@link TransactionPurgeResponse}. It implements the Chlorine SR2 serialization
+ * format.
+ */
+final class TPS implements TransactionPurgeResponse.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionPurgeResponse message;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TPS() {
+ // for Externalizable
+ }
+
+ TPS(final TransactionPurgeResponse message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public TransactionPurgeResponse message() {
+ return verifyNotNull(message);
+ }
+
+ @Override
+ public void setMessage(final TransactionPurgeResponse message) {
+ this.message = requireNonNull(message);
+ }
+
+ @Override
+ public Object readResolve() {
+ return message();
+ }
+}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* A transaction request to perform the abort step of the three-phase commit protocol.
*/
public final class TransactionAbortRequest extends TransactionRequest<TransactionAbortRequest> {
- @Serial
+ interface SerialForm extends TransactionRequest.SerialForm<TransactionAbortRequest> {
+ @Override
+ default TransactionAbortRequest readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence, final ActorRef replyTo) {
+ return new TransactionAbortRequest(target, sequence, replyTo);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionAbortRequest(final TransactionAbortRequest request, final ABIVersion version) {
+ super(request, version);
+ }
+
public TransactionAbortRequest(final TransactionIdentifier target, final long sequence, final ActorRef replyTo) {
super(target, sequence, replyTo);
}
@Override
- protected TransactionAbortRequestProxyV1 externalizableProxy(final ABIVersion version) {
- return new TransactionAbortRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TAR(this) : new TransactionAbortRequestProxyV1(this);
}
@Override
protected TransactionAbortRequest cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionAbortRequest(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link TransactionAbortRequest}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class TransactionAbortRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionAbortRequest> {
- @Serial
+final class TransactionAbortRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionAbortRequest>
+ implements TransactionAbortRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionAbortRequestProxyV1(final TransactionAbortRequest request) {
super(request);
}
-
- @Override
- protected TransactionAbortRequest createRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyTo) {
- return new TransactionAbortRequest(target, sequence, replyTo);
- }
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
public final class TransactionAbortSuccess extends TransactionSuccess<TransactionAbortSuccess> {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<TransactionAbortSuccess> {
+ @Override
+ default TransactionAbortSuccess readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence) {
+ return new TransactionAbortSuccess(target, sequence);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionAbortSuccess(final TransactionAbortSuccess success, final ABIVersion version) {
+ super(success, version);
+ }
+
public TransactionAbortSuccess(final TransactionIdentifier identifier, final long sequence) {
super(identifier, sequence);
}
@Override
- protected AbstractTransactionSuccessProxy<TransactionAbortSuccess> externalizableProxy(final ABIVersion version) {
- return new TransactionAbortSuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TAS(this) : new TransactionAbortSuccessProxyV1(this);
}
@Override
protected TransactionAbortSuccess cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionAbortSuccess(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link TransactionAbortSuccess}. It implements the initial (Boron)
* serialization format.
*
* @author Robert Varga
*/
-final class TransactionAbortSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionAbortSuccess> {
- @Serial
+final class TransactionAbortSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionAbortSuccess>
+ implements TransactionAbortSuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionAbortSuccessProxyV1(final TransactionAbortSuccess success) {
super(success);
}
-
- @Override
- protected TransactionAbortSuccess createSuccess(final TransactionIdentifier target, final long sequence) {
- return new TransactionAbortSuccess(target, sequence);
- }
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
public final class TransactionCanCommitSuccess extends TransactionSuccess<TransactionCanCommitSuccess> {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<TransactionCanCommitSuccess> {
+ @Override
+ default TransactionCanCommitSuccess readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence) {
+ return new TransactionCanCommitSuccess(target, sequence);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionCanCommitSuccess(final TransactionCanCommitSuccess success, final ABIVersion version) {
+ super(success, version);
+ }
+
public TransactionCanCommitSuccess(final TransactionIdentifier identifier, final long sequence) {
super(identifier, sequence);
}
@Override
- protected AbstractTransactionSuccessProxy<TransactionCanCommitSuccess> externalizableProxy(
- final ABIVersion version) {
- return new TransactionCanCommitSuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TCCS(this) : new TransactionCanCommitSuccessProxyV1(this);
}
@Override
protected TransactionCanCommitSuccess cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionCanCommitSuccess(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link TransactionCanCommitSuccess}. It implements the initial (Boron)
* serialization format.
*
* @author Robert Varga
*/
-final class TransactionCanCommitSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionCanCommitSuccess> {
- @Serial
+final class TransactionCanCommitSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionCanCommitSuccess>
+ implements TransactionCanCommitSuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionCanCommitSuccessProxyV1(final TransactionCanCommitSuccess success) {
super(success);
}
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
- }
-
- @Override
- protected TransactionCanCommitSuccess createSuccess(final TransactionIdentifier target, final long sequence) {
- return new TransactionCanCommitSuccess(target, sequence);
- }
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
public final class TransactionCommitSuccess extends TransactionSuccess<TransactionCommitSuccess> {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<TransactionCommitSuccess> {
+ @Override
+ default TransactionCommitSuccess readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence) {
+ return new TransactionCommitSuccess(target, sequence);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionCommitSuccess(final TransactionCommitSuccess success, final ABIVersion version) {
+ super(success, version);
+ }
+
public TransactionCommitSuccess(final TransactionIdentifier identifier, final long sequence) {
super(identifier, sequence);
}
@Override
- protected AbstractTransactionSuccessProxy<TransactionCommitSuccess> externalizableProxy(final ABIVersion version) {
- return new TransactionCommitSuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TCS(this) : new TransactionCommitSuccessProxyV1(this);
}
@Override
protected TransactionCommitSuccess cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionCommitSuccess(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link TransactionCommitSuccess}. It implements the initial (Boron)
* serialization format.
*
* @author Robert Varga
*/
-final class TransactionCommitSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionCommitSuccess> {
- @Serial
+final class TransactionCommitSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionCommitSuccess>
+ implements TransactionCommitSuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionCommitSuccessProxyV1(final TransactionCommitSuccess success) {
super(success);
}
-
- @Override
- protected TransactionCommitSuccess createSuccess(final TransactionIdentifier target, final long sequence) {
- return new TransactionCommitSuccess(target, sequence);
- }
}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* A transaction request to perform the final, doCommit, step of the three-phase commit protocol.
*/
public final class TransactionDoCommitRequest extends TransactionRequest<TransactionDoCommitRequest> {
- @Serial
+ interface SerialForm extends TransactionRequest.SerialForm<TransactionDoCommitRequest> {
+ @Override
+ default TransactionDoCommitRequest readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence, final ActorRef replyTo) {
+ return new TransactionDoCommitRequest(target, sequence, replyTo);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionDoCommitRequest(final TransactionDoCommitRequest request, final ABIVersion version) {
+ super(request, version);
+ }
+
public TransactionDoCommitRequest(final TransactionIdentifier target, final long sequence, final ActorRef replyTo) {
super(target, sequence, replyTo);
}
@Override
- protected TransactionDoCommitRequestProxyV1 externalizableProxy(final ABIVersion version) {
- return new TransactionDoCommitRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TDCR(this) : new TransactionDoCommitRequestProxyV1(this);
}
@Override
protected TransactionDoCommitRequest cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionDoCommitRequest(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link TransactionDoCommitRequest}. It implements the initial (Boron) serialization
* format.
*
* @author Robert Varga
*/
-final class TransactionDoCommitRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionDoCommitRequest> {
- @Serial
+final class TransactionDoCommitRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionDoCommitRequest>
+ implements TransactionDoCommitRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionDoCommitRequestProxyV1(final TransactionDoCommitRequest request) {
super(request);
}
-
- @Override
- protected TransactionDoCommitRequest createRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyTo) {
- return new TransactionDoCommitRequest(target, sequence, replyTo);
- }
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.IOException;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
import org.opendaylight.controller.cluster.access.concepts.RequestFailure;
* Generic {@link RequestFailure} involving a {@link TransactionRequest}.
*/
public final class TransactionFailure extends RequestFailure<TransactionIdentifier, TransactionFailure> {
- @Serial
+ interface SerialForm extends RequestFailure.SerialForm<TransactionIdentifier, TransactionFailure> {
+ @Override
+ default TransactionIdentifier readTarget(final DataInput in) throws IOException {
+ return TransactionIdentifier.readFrom(in);
+ }
+
+ @Override
+ default TransactionFailure createFailure(final TransactionIdentifier target, final long sequence,
+ final RequestException cause) {
+ return new TransactionFailure(target, sequence, cause);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionFailure(final TransactionFailure failure, final ABIVersion version) {
+ super(failure, version);
+ }
+
TransactionFailure(final TransactionIdentifier target, final long sequence, final RequestException cause) {
super(target, sequence, cause);
}
@Override
protected TransactionFailure cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionFailure(this, version);
}
@Override
- protected TransactionFailureProxyV1 externalizableProxy(final ABIVersion version) {
- return new TransactionFailureProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TF(this) : new TransactionFailureProxyV1(this);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.DataInput;
-import java.io.IOException;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.AbstractRequestFailureProxy;
-import org.opendaylight.controller.cluster.access.concepts.RequestException;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
*
* @author Robert Varga
*/
-final class TransactionFailureProxyV1 extends AbstractRequestFailureProxy<TransactionIdentifier, TransactionFailure> {
- @Serial
+final class TransactionFailureProxyV1 extends AbstractRequestFailureProxy<TransactionIdentifier, TransactionFailure>
+ implements TransactionFailure.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionFailureProxyV1(final TransactionFailure failure) {
super(failure);
}
-
- @Override
- protected TransactionFailure createFailure(final TransactionIdentifier target, final long sequence,
- final RequestException cause) {
- return new TransactionFailure(target, sequence, cause);
- }
-
- @Override
- protected TransactionIdentifier readTarget(final DataInput in) throws IOException {
- return TransactionIdentifier.readFrom(in);
- }
}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* A transaction request to perform the second, preCommit, step of the three-phase commit protocol.
*/
public final class TransactionPreCommitRequest extends TransactionRequest<TransactionPreCommitRequest> {
- @Serial
+ interface SerialForm extends TransactionRequest.SerialForm<TransactionPreCommitRequest> {
+ @Override
+ default TransactionPreCommitRequest readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence, final ActorRef replyTo) {
+ return new TransactionPreCommitRequest(target, sequence, replyTo);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionPreCommitRequest(final TransactionPreCommitRequest request, final ABIVersion version) {
+ super(request, version);
+ }
+
public TransactionPreCommitRequest(final TransactionIdentifier target, final long sequence,
final ActorRef replyTo) {
super(target, sequence, replyTo);
}
@Override
- protected TransactionPreCommitRequestProxyV1 externalizableProxy(final ABIVersion version) {
- return new TransactionPreCommitRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TPCR(this) : new TransactionPreCommitRequestProxyV1(this);
}
@Override
protected TransactionPreCommitRequest cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionPreCommitRequest(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link TransactionPreCommitRequest}. It implements the initial (Boron)
* serialization format.
*
* @author Robert Varga
*/
-final class TransactionPreCommitRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionPreCommitRequest> {
- @Serial
+final class TransactionPreCommitRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionPreCommitRequest>
+ implements TransactionPreCommitRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionPreCommitRequestProxyV1(final TransactionPreCommitRequest request) {
super(request);
}
-
- @Override
- protected TransactionPreCommitRequest createRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyTo) {
- return new TransactionPreCommitRequest(target, sequence, replyTo);
- }
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* @author Robert Varga
*/
public final class TransactionPreCommitSuccess extends TransactionSuccess<TransactionPreCommitSuccess> {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<TransactionPreCommitSuccess> {
+ @Override
+ default TransactionPreCommitSuccess readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence) throws IOException {
+ return new TransactionPreCommitSuccess(target, sequence);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionPreCommitSuccess(final TransactionPreCommitSuccess success, final ABIVersion version) {
+ super(success, version);
+ }
+
public TransactionPreCommitSuccess(final TransactionIdentifier identifier, final long sequence) {
super(identifier, sequence);
}
@Override
- protected AbstractTransactionSuccessProxy<TransactionPreCommitSuccess> externalizableProxy(
- final ABIVersion version) {
- return new TransactionPreCommitSuccessProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TPCS(this) : new TransactionPreCommitSuccessProxyV1(this);
}
@Override
protected TransactionPreCommitSuccess cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionPreCommitSuccess(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link TransactionPreCommitSuccess}. It implements the initial (Boron)
* serialization format.
*
* @author Robert Varga
*/
-final class TransactionPreCommitSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionPreCommitSuccess> {
- @Serial
+final class TransactionPreCommitSuccessProxyV1 extends AbstractTransactionSuccessProxy<TransactionPreCommitSuccess>
+ implements TransactionPreCommitSuccess.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionPreCommitSuccessProxyV1(final TransactionPreCommitSuccess success) {
super(success);
}
-
- @Override
- protected TransactionPreCommitSuccess createSuccess(final TransactionIdentifier target, final long sequence) {
- return new TransactionPreCommitSuccess(target, sequence);
- }
}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
* to the transaction and responds with a {@link TransactionPurgeResponse}.
*/
public final class TransactionPurgeRequest extends TransactionRequest<TransactionPurgeRequest> {
- @Serial
+ interface SerialForm extends TransactionRequest.SerialForm<TransactionPurgeRequest> {
+ @Override
+ default TransactionPurgeRequest readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence, final ActorRef replyTo) {
+ return new TransactionPurgeRequest(target, sequence, replyTo);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionPurgeRequest(final TransactionPurgeRequest request, final ABIVersion version) {
+ super(request, version);
+ }
+
public TransactionPurgeRequest(final TransactionIdentifier target, final long sequence, final ActorRef replyTo) {
super(target, sequence, replyTo);
}
@Override
- protected TransactionPurgeRequestProxyV1 externalizableProxy(final ABIVersion version) {
- return new TransactionPurgeRequestProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TPR(this) : new TransactionPurgeRequestProxyV1(this);
}
@Override
protected TransactionPurgeRequest cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionPurgeRequest(this, version);
}
}
\ No newline at end of file
*/
package org.opendaylight.controller.cluster.access.commands;
-import akka.actor.ActorRef;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link TransactionPurgeRequest}. It implements the initial (Boron)
* serialization format.
*
* @author Robert Varga
*/
-final class TransactionPurgeRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionPurgeRequest> {
- @Serial
+final class TransactionPurgeRequestProxyV1 extends AbstractTransactionRequestProxy<TransactionPurgeRequest>
+ implements TransactionPurgeRequest.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionPurgeRequestProxyV1(final TransactionPurgeRequest request) {
super(request);
}
-
- @Override
- protected TransactionPurgeRequest createRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyTo) {
- return new TransactionPurgeRequest(target, sequence, replyTo);
- }
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.ObjectInput;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
/**
* Successful reply to a {@link TransactionPurgeRequest}.
- *
- * @author Robert Varga
*/
+// FIXME: rename to TransactionPurgeSuccess
public final class TransactionPurgeResponse extends TransactionSuccess<TransactionPurgeResponse> {
- @Serial
+ interface SerialForm extends TransactionSuccess.SerialForm<TransactionPurgeResponse> {
+ @Override
+ default TransactionPurgeResponse readExternal(final ObjectInput in, final TransactionIdentifier target,
+ final long sequence) {
+ return new TransactionPurgeResponse(target, sequence);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
+ private TransactionPurgeResponse(final TransactionPurgeResponse success, final ABIVersion version) {
+ super(success, version);
+ }
+
public TransactionPurgeResponse(final TransactionIdentifier identifier, final long sequence) {
super(identifier, sequence);
}
@Override
- protected AbstractTransactionSuccessProxy<TransactionPurgeResponse> externalizableProxy(
- final ABIVersion version) {
- return new TransactionPurgeResponseProxyV1(this);
+ protected SerialForm externalizableProxy(final ABIVersion version) {
+ return ABIVersion.MAGNESIUM.lt(version) ? new TPS(this) : new TransactionPurgeResponseProxyV1(this);
}
@Override
protected TransactionPurgeResponse cloneAsVersion(final ABIVersion version) {
- return this;
+ return new TransactionPurgeResponse(this, version);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-
/**
* Externalizable proxy for use with {@link TransactionPurgeResponse}. It implements the initial (Boron)
* serialization format.
*
* @author Robert Varga
*/
-final class TransactionPurgeResponseProxyV1 extends AbstractTransactionSuccessProxy<TransactionPurgeResponse> {
- @Serial
+final class TransactionPurgeResponseProxyV1 extends AbstractTransactionSuccessProxy<TransactionPurgeResponse>
+ implements TransactionPurgeResponse.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
TransactionPurgeResponseProxyV1(final TransactionPurgeResponse success) {
super(success);
}
-
- @Override
- protected TransactionPurgeResponse createSuccess(final TransactionIdentifier target, final long sequence) {
- return new TransactionPurgeResponse(target, sequence);
- }
}
package org.opendaylight.controller.cluster.access.commands;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.IOException;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.Request;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
* @param <T> Message type
*/
public abstract class TransactionRequest<T extends TransactionRequest<T>> extends Request<TransactionIdentifier, T> {
- @Serial
+ protected interface SerialForm<T extends TransactionRequest<T>>
+ extends Request.SerialForm<TransactionIdentifier, T> {
+ @Override
+ default TransactionIdentifier readTarget(final DataInput in) throws IOException {
+ return TransactionIdentifier.readFrom(in);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
TransactionRequest(final TransactionIdentifier identifier, final long sequence, final ActorRef replyTo) {
}
@Override
- protected abstract AbstractTransactionRequestProxy<T> externalizableProxy(ABIVersion version);
+ protected abstract SerialForm<T> externalizableProxy(ABIVersion version);
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.IOException;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.RequestSuccess;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
*/
public abstract class TransactionSuccess<T extends TransactionSuccess<T>>
extends RequestSuccess<TransactionIdentifier, T> {
- @Serial
+ interface SerialForm<T extends TransactionSuccess<T>> extends RequestSuccess.SerialForm<TransactionIdentifier, T> {
+ @Override
+ default TransactionIdentifier readTarget(final DataInput in) throws IOException {
+ return TransactionIdentifier.readFrom(in);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
TransactionSuccess(final TransactionIdentifier identifier, final long sequence) {
}
@Override
- protected abstract AbstractTransactionSuccessProxy<T> externalizableProxy(ABIVersion version);
+ protected abstract SerialForm<T> externalizableProxy(ABIVersion version);
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import java.io.Serial;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
/**
* typically happens when the linear history ID is newer than the highest observed {@link CreateLocalHistoryRequest}.
*/
public final class UnknownHistoryException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public UnknownHistoryException(final Long lastSeenHistory) {
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import org.opendaylight.yangtools.concepts.WritableObjects;
-
-abstract class AbstractEnvelopeProxy<T extends Message<?, ?>> implements Externalizable {
- @Serial
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+abstract class AbstractEnvelopeProxy<T extends Message<?, ?>, E extends Envelope<T>>
+ implements Envelope.SerialForm<T, E> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private T message;
- private long sessionId;
- private long txSequence;
+ private E envelope;
AbstractEnvelopeProxy() {
// for Externalizable
}
- AbstractEnvelopeProxy(final Envelope<T> envelope) {
- message = envelope.getMessage();
- txSequence = envelope.getTxSequence();
- sessionId = envelope.getSessionId();
+ AbstractEnvelopeProxy(final E envelope) {
+ this.envelope = requireNonNull(envelope);
}
@Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- WritableObjects.writeLongs(out, sessionId, txSequence);
- out.writeObject(message);
+ public final E envelope() {
+ return verifyNotNull(envelope);
}
- @SuppressWarnings("unchecked")
@Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- final byte header = WritableObjects.readLongHeader(in);
- sessionId = WritableObjects.readFirstLong(in, header);
- txSequence = WritableObjects.readSecondLong(in, header);
- message = (T) in.readObject();
+ public final void setEnvelope(final E envelope) {
+ this.envelope = requireNonNull(envelope);
}
- @SuppressWarnings("checkstyle:hiddenField")
- abstract Envelope<T> createEnvelope(T wrappedNessage, long sessionId, long txSequence);
-
- @Serial
- final Object readResolve() {
- return createEnvelope(message, sessionId, txSequence);
+ @Override
+ public final Object readResolve() {
+ return envelope();
}
}
package org.opendaylight.controller.cluster.access.concepts;
import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
-import java.io.DataInput;
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
-import org.opendaylight.yangtools.concepts.WritableObjects;
/**
* Abstract Externalizable proxy for use with {@link Message} subclasses.
* @param <T> Target identifier type
* @param <C> Message class
*/
-abstract class AbstractMessageProxy<T extends WritableIdentifier, C extends Message<T, C>> implements Externalizable {
- @Serial
+abstract class AbstractMessageProxy<T extends WritableIdentifier, C extends Message<T, C>>
+ implements Message.SerialForm<T, C> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private T target;
- private long sequence;
+ private C message;
protected AbstractMessageProxy() {
// For Externalizable
}
AbstractMessageProxy(final @NonNull C message) {
- this.target = message.getTarget();
- this.sequence = message.getSequence();
+ this.message = requireNonNull(message);
}
@Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- target.writeTo(out);
- WritableObjects.writeLong(out, sequence);
+ public final C message() {
+ return verifyNotNull(message);
}
@Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- target = verifyNotNull(readTarget(in));
- sequence = WritableObjects.readLong(in);
+ public final void setMessage(final C message) {
+ this.message = requireNonNull(message);
}
- @Serial
- protected final Object readResolve() {
- return verifyNotNull(createMessage(target, sequence));
+ @Override
+ public final Object readResolve() {
+ return message();
}
-
- protected abstract @NonNull T readTarget(@NonNull DataInput in) throws IOException;
-
- abstract @NonNull C createMessage(@NonNull T msgTarget, long msgSequence);
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
* @param <T> Target identifier type
*/
public abstract class AbstractRequestFailureProxy<T extends WritableIdentifier, C extends RequestFailure<T, C>>
- extends AbstractResponseProxy<T, C> {
- @Serial
+ extends AbstractResponseProxy<T, C> implements RequestFailure.SerialForm<T, C> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private RequestException cause;
-
protected AbstractRequestFailureProxy() {
// For Externalizable
}
protected AbstractRequestFailureProxy(final @NonNull C failure) {
super(failure);
- this.cause = failure.getCause();
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
- out.writeObject(cause);
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
- cause = (RequestException) in.readObject();
- }
-
- @Override
- final C createResponse(final T target, final long sequence) {
- return createFailure(target, sequence, cause);
}
-
- protected abstract @NonNull C createFailure(@NonNull T target, long sequence,
- @NonNull RequestException failureCause);
-}
+}
\ No newline at end of file
*/
package org.opendaylight.controller.cluster.access.concepts;
-import akka.actor.ActorRef;
-import akka.serialization.JavaSerializer;
-import akka.serialization.Serialization;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
* @param <T> Target identifier type
*/
public abstract class AbstractRequestProxy<T extends WritableIdentifier, C extends Request<T, C>>
- extends AbstractMessageProxy<T, C> {
- @Serial
+ extends AbstractMessageProxy<T, C> implements Request.SerialForm<T, C> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private ActorRef replyTo;
-
protected AbstractRequestProxy() {
// For Externalizable
}
protected AbstractRequestProxy(final @NonNull C request) {
super(request);
- this.replyTo = request.getReplyTo();
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
- out.writeObject(Serialization.serializedActorPath(replyTo));
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
- replyTo = JavaSerializer.currentSystem().value().provider().resolveActorRef((String) in.readObject());
- }
-
- @Override
- final C createMessage(final T target, final long sequence) {
- return createRequest(target, sequence, replyTo);
}
-
- protected abstract @NonNull C createRequest(@NonNull T target, long sequence, @NonNull ActorRef replyToActor);
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import org.opendaylight.yangtools.concepts.WritableObjects;
-
-abstract class AbstractResponseEnvelopeProxy<T extends Response<?, ?>> extends AbstractEnvelopeProxy<T> {
- @Serial
+abstract class AbstractResponseEnvelopeProxy<T extends Response<?, ?>, E extends ResponseEnvelope<T>>
+ extends AbstractEnvelopeProxy<T, E> {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private long executionTimeNanos;
-
AbstractResponseEnvelopeProxy() {
// for Externalizable
}
- AbstractResponseEnvelopeProxy(final ResponseEnvelope<T> envelope) {
+ AbstractResponseEnvelopeProxy(final E envelope) {
super(envelope);
- this.executionTimeNanos = envelope.getExecutionTimeNanos();
}
-
- @Override
- public final void writeExternal(final ObjectOutput out) throws IOException {
- super.writeExternal(out);
- WritableObjects.writeLong(out, executionTimeNanos);
- }
-
- @Override
- public final void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
- executionTimeNanos = WritableObjects.readLong(in);
- }
-
- @Override
- final ResponseEnvelope<T> createEnvelope(final T message, final long sessionId, final long txSequence) {
- return createEnvelope(message, sessionId, txSequence, executionTimeNanos);
- }
-
- @SuppressWarnings("checkstyle:hiddenField")
- abstract ResponseEnvelope<T> createEnvelope(T message, long sessionId, long txSequence, long executionTimeNanos);
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
*/
abstract class AbstractResponseProxy<T extends WritableIdentifier, C extends Response<T, C>>
extends AbstractMessageProxy<T, C> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
protected AbstractResponseProxy() {
AbstractResponseProxy(final @NonNull C response) {
super(response);
}
-
- @Override
- final C createMessage(final T target, final long sequence) {
- return createResponse(target, sequence);
- }
-
- abstract @NonNull C createResponse(@NonNull T target, long sequence);
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
*/
public abstract class AbstractSuccessProxy<T extends WritableIdentifier, C extends RequestSuccess<T, C>>
extends AbstractResponseProxy<T, C> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
protected AbstractSuccessProxy() {
protected AbstractSuccessProxy(final @NonNull C success) {
super(success);
}
-
- @Override
- final C createResponse(final T target, final long sequence) {
- return createSuccess(target, sequence);
- }
-
- protected abstract @NonNull C createSuccess(@NonNull T target, long sequence);
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.concepts;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Serialization proxy for {@link ClientIdentifier}.
+ */
+final class CI implements ClientIdentifier.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private ClientIdentifier identifier;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public CI() {
+ // for Externalizable
+ }
+
+ CI(final ClientIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
+ }
+
+ @Override
+ public ClientIdentifier identifier() {
+ return verifyNotNull(identifier);
+ }
+
+ @Override
+ public void setIdentifier(final ClientIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
+ }
+
+ @Override
+ public Object readResolve() {
+ return identifier();
+ }
+}
*/
package org.opendaylight.controller.cluster.access.concepts;
+import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.cds.types.rev191024.ClientGeneration;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
/**
* A cluster-wide unique identifier of a frontend instance. This identifier discerns between individual incarnations
* of a particular frontend.
- *
- * @author Robert Varga
*/
public final class ClientIdentifier implements WritableIdentifier {
- private static final class Proxy implements Externalizable {
- @Serial
+ interface SerialForm extends Externalizable {
+ @NonNull ClientIdentifier identifier();
+
+ void setIdentifier(@NonNull ClientIdentifier identifier);
+
+ @java.io.Serial
+ Object readResolve();
+
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException {
+ setIdentifier(new ClientIdentifier(FrontendIdentifier.readFrom(in), WritableObjects.readLong(in)));
+ }
+
+ @Override
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ final var id = identifier();
+ id.getFrontendId().writeTo(out);
+ WritableObjects.writeLong(out, id.getGeneration());
+ }
+ }
+
+ private static final class Proxy implements SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private FrontendIdentifier frontendId;
- private long generation;
+ private ClientIdentifier identifier;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
// Needed for Externalizable
}
- Proxy(final FrontendIdentifier frontendId, final long generation) {
- this.frontendId = requireNonNull(frontendId);
- this.generation = generation;
+ Proxy(final ClientIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
}
@Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- frontendId.writeTo(out);
- WritableObjects.writeLong(out, generation);
+ public ClientIdentifier identifier() {
+ return verifyNotNull(identifier);
}
@Override
- public void readExternal(final ObjectInput in) throws IOException {
- frontendId = FrontendIdentifier.readFrom(in);
- generation = WritableObjects.readLong(in);
+ public void setIdentifier(final ClientIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
}
- @Serial
- private Object readResolve() {
- return new ClientIdentifier(frontendId, generation);
+ @Override
+ public Object readResolve() {
+ return identifier();
}
}
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull FrontendIdentifier frontendId;
.toString();
}
- @Serial
+ @java.io.Serial
private Object writeReplace() {
- return new Proxy(frontendId, generation);
+ return new Proxy(this);
}
}
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
-import java.io.Serial;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import java.io.Serializable;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.concepts.WritableObjects;
public abstract class Envelope<T extends Message<?, ?>> implements Immutable, Serializable {
- @Serial
+ interface SerialForm<T extends Message<?, ?>, E extends Envelope<T>> extends Externalizable {
+
+ @NonNull E envelope();
+
+ void setEnvelope(@NonNull E envelope);
+
+ @java.io.Serial
+ Object readResolve();
+
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ final byte header = WritableObjects.readLongHeader(in);
+ final var sessionId = WritableObjects.readFirstLong(in, header);
+ final var txSequence = WritableObjects.readSecondLong(in, header);
+ @SuppressWarnings("unchecked")
+ final var message = (T) in.readObject();
+ setEnvelope(readExternal(in, sessionId, txSequence, message));
+ }
+
+ E readExternal(ObjectInput in, long sessionId, long txSequence, T message) throws IOException;
+
+ @Override
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ writeExternal(out, envelope());
+ }
+
+ default void writeExternal(final ObjectOutput out, final @NonNull E envelope) throws IOException {
+ WritableObjects.writeLongs(out, envelope.getSessionId(), envelope.getTxSequence());
+ out.writeObject(envelope.getMessage());
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull T message;
.add("txSequence", Long.toHexString(txSequence)).add("message", message).toString();
}
- @Serial
+ @java.io.Serial
final Object writeReplace() {
- return createProxy();
+ return ABIVersion.MAGNESIUM.lt(message.getVersion()) ? createProxy() : legacyProxy();
}
- abstract AbstractEnvelopeProxy<T> createProxy();
+ abstract @NonNull SerialForm<T, ?> createProxy();
+
+ abstract @NonNull AbstractEnvelopeProxy<T, ?> legacyProxy();
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.concepts;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Serialization proxy for {@link FailureEnvelope}.
+ */
+final class FE implements FailureEnvelope.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private FailureEnvelope envelope;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public FE() {
+ // for Externalizable
+ }
+
+ FE(final FailureEnvelope envelope) {
+ this.envelope = requireNonNull(envelope);
+ }
+
+ @Override
+ public FailureEnvelope envelope() {
+ return verifyNotNull(envelope);
+ }
+
+ @Override
+ public void setEnvelope(final FailureEnvelope envelope) {
+ this.envelope = requireNonNull(envelope);
+ }
+
+ @Override
+ public Object readResolve() {
+ return envelope();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.concepts;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Serialization proxy for {@link FrontendIdentifier}.
+ */
+final class FI implements FrontendIdentifier.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private FrontendIdentifier identifier;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public FI() {
+ // for Externalizable
+ }
+
+ FI(final FrontendIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
+ }
+
+ @Override
+ public FrontendIdentifier identifier() {
+ return verifyNotNull(identifier);
+ }
+
+ @Override
+ public void setIdentifier(final FrontendIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
+ }
+
+ @Override
+ public Object readResolve() {
+ return identifier();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.concepts;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Serialization proxy for {@link FrontendType}.
+ */
+final class FT implements FrontendType.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private FrontendType type;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public FT() {
+ // for Externalizable
+ }
+
+ FT(final FrontendType type) {
+ this.type = requireNonNull(type);
+ }
+
+ @Override
+ public FrontendType type() {
+ return verifyNotNull(type);
+ }
+
+ @Override
+ public void setType(final FrontendType type) {
+ this.type = requireNonNull(type);
+ }
+
+ @Override
+ public Object readResolve() {
+ return type();
+ }
+}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
+import java.io.ObjectInput;
public final class FailureEnvelope extends ResponseEnvelope<RequestFailure<?, ?>> {
- @Serial
+ interface SerialForm extends ResponseEnvelope.SerialForm<RequestFailure<?, ?>, FailureEnvelope> {
+ @Override
+ default FailureEnvelope readExternal(final ObjectInput in, final long sessionId, final long txSequence,
+ final RequestFailure<?, ?> message, final long executionTimeNanos) {
+ return new FailureEnvelope(message, sessionId, txSequence, executionTimeNanos);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public FailureEnvelope(final RequestFailure<?, ?> message, final long sessionId, final long txSequence,
}
@Override
- FailureEnvelopeProxy createProxy() {
+ FE createProxy() {
+ return new FE(this);
+ }
+
+ @Override
+ FailureEnvelopeProxy legacyProxy() {
return new FailureEnvelopeProxy(this);
}
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
-
-final class FailureEnvelopeProxy extends AbstractResponseEnvelopeProxy<RequestFailure<?, ?>> {
- @Serial
+final class FailureEnvelopeProxy extends AbstractResponseEnvelopeProxy<RequestFailure<?, ?>, FailureEnvelope>
+ implements FailureEnvelope.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to be
FailureEnvelopeProxy(final FailureEnvelope envelope) {
super(envelope);
}
-
- @Override
- ResponseEnvelope<RequestFailure<?, ?>> createEnvelope(final RequestFailure<?, ?> message, final long sessionId,
- final long txSequence, final long executionTimeNanos) {
- return new FailureEnvelope(message, sessionId, txSequence, executionTimeNanos);
- }
}
*/
package org.opendaylight.controller.cluster.access.concepts;
+import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import java.io.DataInput;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import java.util.Objects;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
* A cluster-wide unique identifier of a frontend type located at a cluster member.
*/
public final class FrontendIdentifier implements WritableIdentifier {
- private static final class Proxy implements Externalizable {
- @Serial
+ interface SerialForm extends Externalizable {
+ @NonNull FrontendIdentifier identifier();
+
+ void setIdentifier(@NonNull FrontendIdentifier identifier);
+
+ @java.io.Serial
+ Object readResolve();
+
+ @Override
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ final var id = identifier();
+ id.memberName.writeTo(out);
+ id.clientType.writeTo(out);
+ }
+
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException {
+ setIdentifier(new FrontendIdentifier(MemberName.readFrom(in), FrontendType.readFrom(in)));
+ }
+ }
+
+ private static final class Proxy implements SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private MemberName memberName;
- private FrontendType clientType;
+ private FrontendIdentifier identifier;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
// Needed for Externalizable
}
- Proxy(final MemberName memberName, final FrontendType clientType) {
- this.memberName = requireNonNull(memberName);
- this.clientType = requireNonNull(clientType);
+ Proxy(final FrontendIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
}
@Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- memberName.writeTo(out);
- clientType.writeTo(out);
+ public FrontendIdentifier identifier() {
+ return verifyNotNull(identifier);
}
@Override
- public void readExternal(final ObjectInput in) throws IOException {
- memberName = MemberName.readFrom(in);
- clientType = FrontendType.readFrom(in);
+ public void setIdentifier(final FrontendIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
}
- @Serial
- private Object readResolve() {
- return new FrontendIdentifier(memberName, clientType);
+ @Override
+ public Object readResolve() {
+ return identifier();
}
}
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final MemberName memberName;
return toPersistentId();
}
- @Serial
+ @java.io.Serial
private Object writeReplace() {
- return new Proxy(memberName, clientType);
+ return new Proxy(this);
}
}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import java.nio.charset.StandardCharsets;
import java.util.regex.Pattern;
import org.eclipse.jdt.annotation.NonNull;
* discerned.
*/
public final class FrontendType implements Comparable<FrontendType>, WritableIdentifier {
- private static final class Proxy implements Externalizable {
- @Serial
+ interface SerialForm extends Externalizable {
+ @NonNull FrontendType type();
+
+ void setType(@NonNull FrontendType type);
+
+ @java.io.Serial
+ Object readResolve();
+
+ @Override
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ final var serialized = type().getSerialized();
+ out.writeInt(serialized.length);
+ out.write(serialized);
+ }
+
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException {
+ final var serialized = new byte[in.readInt()];
+ in.readFully(serialized);
+ // TODO: consider caching instances here
+ setType(new FrontendType(new String(serialized, StandardCharsets.UTF_8), serialized));
+ }
+ }
+
+ private static final class Proxy implements SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private byte[] serialized;
+ private FrontendType type;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
// For Externalizable
}
- Proxy(final byte[] serialized) {
- this.serialized = requireNonNull(serialized);
+ Proxy(final FrontendType type) {
+ this.type = requireNonNull(type);
}
@Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- out.writeInt(serialized.length);
- out.write(serialized);
+ public FrontendType type() {
+ return verifyNotNull(type);
}
@Override
- public void readExternal(final ObjectInput in) throws IOException {
- serialized = new byte[in.readInt()];
- in.readFully(serialized);
+ public void setType(final FrontendType type) {
+ this.type = requireNonNull(type);
}
- @Serial
- private Object readResolve() {
- // TODO: consider caching instances here
- return new FrontendType(new String(serialized, StandardCharsets.UTF_8), serialized);
+ @Override
+ public Object readResolve() {
+ return type();
}
}
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
private static final String SIMPLE_STRING_REGEX = "^[a-zA-Z0-9-_.*+:=,!~';]+$";
private static final Pattern SIMPLE_STRING_PATTERN = Pattern.compile(SIMPLE_STRING_REGEX);
- @Serial
- private static final long serialVersionUID = 1L;
private final @NonNull String name;
return local;
}
- @Serial
+ @java.io.Serial
Object writeReplace() {
- return new Proxy(getSerialized());
+ return new Proxy(this);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.concepts;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Serialization proxy for {@link LocalHistoryIdentifier}.
+ */
+final class HI implements LocalHistoryIdentifier.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private LocalHistoryIdentifier identifier;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public HI() {
+ // for Externalizable
+ }
+
+ HI(final LocalHistoryIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
+ }
+
+ @Override
+ public LocalHistoryIdentifier identifier() {
+ return verifyNotNull(identifier);
+ }
+
+ @Override
+ public void setIdentifier(final LocalHistoryIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
+ }
+
+ @Override
+ public Object readResolve() {
+ return identifier();
+ }
+}
*/
package org.opendaylight.controller.cluster.access.concepts;
+import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
import org.opendaylight.yangtools.concepts.WritableObjects;
* - an unsigned long cookie, assigned by the client and meaningless on the backend, which just reflects it back
*/
public final class LocalHistoryIdentifier implements WritableIdentifier {
- /*
- * Implementation note: cookie is currently required only for module-based sharding, which is implemented as part
- * of normal DataBroker interfaces. For DOMDataTreeProducer cookie will always be zero, hence
- * we may end up not needing cookie at all.
+ /**
+ * Serialized form of {@link LocalHistoryIdentifier}.
*
- * We use WritableObjects.writeLongs() to output historyId and cookie (in that order). If we
- * end up not needing the cookie at all, we can switch to writeLong() and use zero flags for
- * compatibility.
+ * @implNote
+ * cookie is currently required only for module-based sharding, which is implemented as part of normal
+ * DataBroker interfaces. For DOMDataTreeProducer cookie will always be zero, hence we may end up not needing
+ * cookie at all.
+ * We use WritableObjects.writeLongs() to output historyId and cookie (in that order). If we end up not needing
+ * the cookie at all, we can switch to writeLong() and use zero flags for compatibility.
*/
- private static final class Proxy implements Externalizable {
- @Serial
+ interface SerialForm extends Externalizable {
+ @NonNull LocalHistoryIdentifier identifier();
+
+ void setIdentifier(@NonNull LocalHistoryIdentifier identifier);
+
+ @java.io.Serial
+ Object readResolve();
+
+ @Override
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ final var id = identifier();
+ id.getClientId().writeTo(out);
+ WritableObjects.writeLongs(out, id.getHistoryId(), id.getCookie());
+ }
+
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException {
+ final var clientId = ClientIdentifier.readFrom(in);
+
+ final byte header = WritableObjects.readLongHeader(in);
+ final var historyId = WritableObjects.readFirstLong(in, header);
+ final var cookie = WritableObjects.readSecondLong(in, header);
+ setIdentifier(new LocalHistoryIdentifier(clientId, historyId, cookie));
+ }
+ }
+
+ private static final class Proxy implements SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private ClientIdentifier clientId;
- private long historyId;
- private long cookie;
+ private LocalHistoryIdentifier identifier;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
// For Externalizable
}
- Proxy(final ClientIdentifier frontendId, final long historyId, final long cookie) {
- clientId = requireNonNull(frontendId);
- this.historyId = historyId;
- this.cookie = cookie;
+ Proxy(final LocalHistoryIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
}
@Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- clientId.writeTo(out);
- WritableObjects.writeLongs(out, historyId, cookie);
+ public LocalHistoryIdentifier identifier() {
+ return verifyNotNull(identifier);
}
@Override
- public void readExternal(final ObjectInput in) throws IOException {
- clientId = ClientIdentifier.readFrom(in);
-
- final byte header = WritableObjects.readLongHeader(in);
- historyId = WritableObjects.readFirstLong(in, header);
- cookie = WritableObjects.readSecondLong(in, header);
+ public void setIdentifier(final LocalHistoryIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
}
- @Serial
- private Object readResolve() {
- return new LocalHistoryIdentifier(clientId, historyId, cookie);
+ @Override
+ public Object readResolve() {
+ return identifier();
}
}
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull ClientIdentifier clientId;
.add("cookie", Long.toUnsignedString(cookie, 16)).toString();
}
- @Serial
+ @java.io.Serial
private Object writeReplace() {
- return new Proxy(clientId, historyId, cookie);
+ return new Proxy(this);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.concepts;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Serialization proxy for {@link MemberName}.
+ */
+final class MN implements MemberName.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private MemberName name;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public MN() {
+ // for Externalizable
+ }
+
+ MN(final MemberName name) {
+ this.name = requireNonNull(name);
+ }
+
+ @Override
+ public MemberName name() {
+ return verifyNotNull(name);
+ }
+
+ @Override
+ public void setName(final MemberName name) {
+ this.name = requireNonNull(name);
+ }
+
+ @Override
+ public Object readResolve() {
+ return name();
+ }
+}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import java.nio.charset.StandardCharsets;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
* Type-safe encapsulation of a cluster member name.
*/
public final class MemberName implements Comparable<MemberName>, WritableIdentifier {
- private static final class Proxy implements Externalizable {
- @Serial
+ interface SerialForm extends Externalizable {
+ @NonNull MemberName name();
+
+ void setName(@NonNull MemberName name);
+
+ @java.io.Serial
+ Object readResolve();
+
+ @Override
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ final var serialized = name().getSerialized();
+ out.writeInt(serialized.length);
+ out.write(serialized);
+ }
+
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException {
+ final var serialized = new byte[in.readInt()];
+ in.readFully(serialized);
+ // TODO: consider caching instances here
+ setName(new MemberName(new String(serialized, StandardCharsets.UTF_8), serialized));
+ }
+ }
+
+ private static final class Proxy implements SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private byte[] serialized;
+ private MemberName name;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
// For Externalizable
}
- Proxy(final byte[] serialized) {
- this.serialized = requireNonNull(serialized);
+ Proxy(final MemberName name) {
+ this.name = requireNonNull(name);
}
@Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- out.writeInt(serialized.length);
- out.write(serialized);
+ public MemberName name() {
+ return verifyNotNull(name);
}
@Override
- public void readExternal(final ObjectInput in) throws IOException {
- serialized = new byte[in.readInt()];
- in.readFully(serialized);
+ public void setName(final MemberName name) {
+ this.name = requireNonNull(name);
}
- @Serial
- private Object readResolve() {
- // TODO: consider caching instances here
- return new MemberName(new String(serialized, StandardCharsets.UTF_8), serialized);
+ @Override
+ public Object readResolve() {
+ return name();
}
}
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull String name;
return local;
}
- @Serial
+ @java.io.Serial
Object writeReplace() {
- return new Proxy(getSerialized());
+ return new Proxy(this);
}
}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import java.io.Serial;
+import java.io.DataInput;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import java.io.Serializable;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
+import org.opendaylight.yangtools.concepts.WritableObjects;
/**
* An abstract concept of a Message. This class cannot be instantiated directly, use its specializations {@link Request}
* @param <T> Target identifier type
* @param <C> Message type
*/
-public abstract class Message<T extends WritableIdentifier, C extends Message<T, C>> implements Immutable,
- Serializable {
- @Serial
+public abstract class Message<T extends WritableIdentifier, C extends Message<T, C>>
+ implements Immutable, Serializable {
+ /**
+ * Externalizable proxy for use with {@link Message} subclasses.
+ *
+ * @param <T> Target identifier type
+ * @param <C> Message class
+ */
+ protected interface SerialForm<T extends WritableIdentifier, C extends Message<T, C>> extends Externalizable {
+
+ @NonNull C message();
+
+ void setMessage(@NonNull C message);
+
+ @Override
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ final var message = message();
+ message.getTarget().writeTo(out);
+ WritableObjects.writeLong(out, message.getSequence());
+ writeExternal(out, message);
+ }
+
+ void writeExternal(@NonNull ObjectOutput out, @NonNull C msg) throws IOException;
+
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
+ final var target = verifyNotNull(readTarget(in));
+ final var sequence = WritableObjects.readLong(in);
+ setMessage(verifyNotNull(readExternal(in, target, sequence)));
+ }
+
+ @NonNull C readExternal(@NonNull ObjectInput in, @NonNull T target, long sequence)
+ throws IOException, ClassNotFoundException;
+
+ Object readResolve();
+
+ @NonNull T readTarget(@NonNull DataInput in) throws IOException;
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull ABIVersion version;
* @param reqVersion Requested ABI version
* @return Proxy for this object
*/
- abstract @NonNull AbstractMessageProxy<T, C> externalizableProxy(@NonNull ABIVersion reqVersion);
+ protected abstract @NonNull SerialForm<T, C> externalizableProxy(@NonNull ABIVersion reqVersion);
- @Serial
+ @java.io.Serial
protected final Object writeReplace() {
return externalizableProxy(version);
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.concepts;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Serialization proxy for {@link RequestEnvelope}.
+ */
+final class RE implements RequestEnvelope.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private RequestEnvelope envelope;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public RE() {
+ // for Externalizable
+ }
+
+ RE(final RequestEnvelope envelope) {
+ this.envelope = requireNonNull(envelope);
+ }
+
+ @Override
+ public RequestEnvelope envelope() {
+ return verifyNotNull(envelope);
+ }
+
+ @Override
+ public void setEnvelope(final RequestEnvelope envelope) {
+ this.envelope = requireNonNull(envelope);
+ }
+
+ @Override
+ public Object readResolve() {
+ return envelope();
+ }
+}
import static java.util.Objects.requireNonNull;
import akka.actor.ActorRef;
+import akka.serialization.JavaSerializer;
+import akka.serialization.Serialization;
import com.google.common.base.MoreObjects.ToStringHelper;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
* @param <C> Message type
*/
public abstract class Request<T extends WritableIdentifier, C extends Request<T, C>> extends Message<T, C> {
- @Serial
+ protected interface SerialForm<T extends WritableIdentifier, C extends Request<T, C>>
+ extends Message.SerialForm<T, C> {
+ @Override
+ default C readExternal(final ObjectInput in, final T target, final long sequence)
+ throws ClassNotFoundException, IOException {
+ return readExternal(in, target, sequence,
+ JavaSerializer.currentSystem().value().provider().resolveActorRef((String) in.readObject()));
+ }
+
+ @NonNull C readExternal(@NonNull ObjectInput in, @NonNull T target, long sequence, @NonNull ActorRef replyTo)
+ throws IOException;
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final C msg) throws IOException {
+ out.writeObject(Serialization.serializedActorPath(msg.getReplyTo()));
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull ActorRef replyTo;
}
@Override
- protected abstract AbstractRequestProxy<T, C> externalizableProxy(ABIVersion version);
+ protected abstract SerialForm<T, C> externalizableProxy(ABIVersion version);
}
package org.opendaylight.controller.cluster.access.concepts;
import akka.actor.ActorRef;
-import java.io.Serial;
+import java.io.ObjectInput;
public final class RequestEnvelope extends Envelope<Request<?, ?>> {
- @Serial
+ interface SerialForm extends Envelope.SerialForm<Request<?, ?>, RequestEnvelope> {
+ @Override
+ default RequestEnvelope readExternal(final ObjectInput in, final long sessionId, final long txSequence,
+ final Request<?, ?> message) {
+ return new RequestEnvelope(message, sessionId, txSequence);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public RequestEnvelope(final Request<?, ?> message, final long sessionId, final long txSequence) {
}
@Override
- RequestEnvelopeProxy createProxy() {
+ RE createProxy() {
+ return new RE(this);
+ }
+
+ @Override
+ RequestEnvelopeProxy legacyProxy() {
return new RequestEnvelopeProxy(this);
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
-
-final class RequestEnvelopeProxy extends AbstractEnvelopeProxy<Request<?, ?>> {
- @Serial
+final class RequestEnvelopeProxy extends AbstractEnvelopeProxy<Request<?, ?>, RequestEnvelope>
+ implements RequestEnvelope.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
RequestEnvelopeProxy(final RequestEnvelope envelope) {
super(envelope);
}
-
- @Override
- RequestEnvelope createEnvelope(final Request<?, ?> message, final long sessionId, final long txSequence) {
- return new RequestEnvelope(message, sessionId, txSequence);
- }
}
import static java.util.Objects.requireNonNull;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
/**
* A failure cause behind a {@link RequestFailure} to process a {@link Request}.
*/
public abstract class RequestException extends Exception {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
protected RequestException(final @NonNull String message) {
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects.ToStringHelper;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
*/
public abstract class RequestFailure<T extends WritableIdentifier, C extends RequestFailure<T, C>>
extends Response<T, C> {
- @Serial
+ /**
+ * Externalizable proxy for use with {@link RequestFailure} subclasses.
+ *
+ * @param <T> Target identifier type
+ */
+ protected interface SerialForm<T extends WritableIdentifier, C extends RequestFailure<T, C>>
+ extends Message.SerialForm<T, C> {
+ @Override
+ default C readExternal(final ObjectInput in, final T target, final long sequence)
+ throws IOException, ClassNotFoundException {
+ return createFailure(target, sequence, (RequestException) in.readObject());
+ }
+
+ @Override
+ default void writeExternal(final ObjectOutput out, final C msg) throws IOException {
+ out.writeObject(msg.getCause());
+ }
+
+ @NonNull C createFailure(@NonNull T target, long sequence, @NonNull RequestException failureCause);
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull RequestException cause;
}
@Override
- protected abstract AbstractRequestFailureProxy<T, C> externalizableProxy(ABIVersion version);
+ protected abstract SerialForm<T, C> externalizableProxy(ABIVersion version);
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
+import java.io.IOException;
+import java.io.ObjectOutput;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
*
* @param <T> Target identifier type
*/
-public abstract class RequestSuccess<T extends WritableIdentifier, C extends RequestSuccess<T, C>> extends
- Response<T, C> {
- @Serial
+public abstract class RequestSuccess<T extends WritableIdentifier, C extends RequestSuccess<T, C>>
+ extends Response<T, C> {
+ protected interface SerialForm<T extends WritableIdentifier, C extends RequestSuccess<T, C>>
+ extends Response.SerialForm<T, C> {
+ @Override
+ default void writeExternal(final ObjectOutput out, final C msg) throws IOException {
+ // Defaults to no-op
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- protected RequestSuccess(final @NonNull C success, final @NonNull ABIVersion version) {
+ protected RequestSuccess(final @NonNull C success, final @NonNull ABIVersion version) {
super(success, version);
}
protected RequestSuccess(final @NonNull T target, final long sequence) {
super(target, sequence);
}
-
- @Override
- protected abstract AbstractSuccessProxy<T, C> externalizableProxy(ABIVersion version);
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
* @param <C> Message type
*/
public abstract class Response<T extends WritableIdentifier, C extends Response<T, C>> extends Message<T, C> {
- @Serial
+ protected interface SerialForm<T extends WritableIdentifier, C extends Response<T, C>>
+ extends Message.SerialForm<T, C> {
+
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
Response(final @NonNull T target, final long sequence) {
Response(final @NonNull C response, final @NonNull ABIVersion version) {
super(response, version);
}
-
- @Override
- abstract AbstractResponseProxy<T, C> externalizableProxy(ABIVersion version);
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import com.google.common.base.Preconditions;
-import java.io.Serial;
+import static com.google.common.base.Preconditions.checkArgument;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.concepts.WritableObjects;
public abstract class ResponseEnvelope<T extends Response<?, ?>> extends Envelope<T> {
- @Serial
+ interface SerialForm<T extends Response<?, ?>, E extends ResponseEnvelope<T>> extends Envelope.SerialForm<T, E> {
+ @Override
+ default void writeExternal(final ObjectOutput out, final @NonNull E envelope) throws IOException {
+ Envelope.SerialForm.super.writeExternal(out, envelope);
+ WritableObjects.writeLong(out, envelope.getExecutionTimeNanos());
+ }
+
+ @Override
+ default E readExternal(final ObjectInput in, final long sessionId, final long txSequence, final T message)
+ throws IOException {
+ return readExternal(in, sessionId, txSequence, message, WritableObjects.readLong(in));
+ }
+
+ E readExternal(ObjectInput in, long sessionId, long txSequence, T message, long executionTimeNanos);
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final long executionTimeNanos;
ResponseEnvelope(final T message, final long sessionId, final long txSequence, final long executionTimeNanos) {
super(message, sessionId, txSequence);
- Preconditions.checkArgument(executionTimeNanos >= 0);
+ checkArgument(executionTimeNanos >= 0, "Negative executionTime");
this.executionTimeNanos = executionTimeNanos;
}
public final long getExecutionTimeNanos() {
return executionTimeNanos;
}
-
- @Override
- abstract AbstractResponseEnvelopeProxy<T> createProxy();
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
-
/**
* General error raised when the recipient of a {@link Request} determines that the request contains
* a {@link ClientIdentifier} which corresponds to an outdated generation.
*/
public final class RetiredGenerationException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public RetiredGenerationException(final long originatingGeneration, final long newGeneration) {
import static java.util.Objects.requireNonNull;
import com.google.common.base.Strings;
-import java.io.Serial;
/**
* General error raised when the recipient of a {@link Request} fails to process a request.
*/
public final class RuntimeRequestException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public RuntimeRequestException(final String message, final Throwable cause) {
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.concepts;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+import java.io.ObjectInput;
+
+/**
+ * Serialization proxy for {@link SuccessEnvelope}.
+ */
+final class SE implements SuccessEnvelope.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private SuccessEnvelope envelope;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public SE() {
+ // for Externalizable
+ }
+
+ SE(final SuccessEnvelope envelope) {
+ this.envelope = requireNonNull(envelope);
+ }
+
+ @Override
+ public SuccessEnvelope envelope() {
+ return verifyNotNull(envelope);
+ }
+
+ @Override
+ public void setEnvelope(final SuccessEnvelope envelope) {
+ this.envelope = requireNonNull(envelope);
+ }
+
+ @Override
+ public SuccessEnvelope readExternal(final ObjectInput in, final long sessionId, final long txSequence,
+ final RequestSuccess<?, ?> message, final long executionTimeNanos) {
+ return new SuccessEnvelope(message, sessionId, txSequence, executionTimeNanos);
+ }
+
+ @Override
+ public Object readResolve() {
+ return envelope();
+ }
+}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
+import java.io.ObjectInput;
public final class SuccessEnvelope extends ResponseEnvelope<RequestSuccess<?, ?>> {
- @Serial
+ interface SerialForm extends ResponseEnvelope.SerialForm<RequestSuccess<?, ?>, SuccessEnvelope> {
+ @Override
+ default SuccessEnvelope readExternal(final ObjectInput in, final long sessionId, final long txSequence,
+ final RequestSuccess<?, ?> message, final long executionTimeNanos) {
+ return new SuccessEnvelope(message, sessionId, txSequence, executionTimeNanos);
+ }
+ }
+
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public SuccessEnvelope(final RequestSuccess<?, ?> message, final long sessionId, final long txSequence,
}
@Override
- SuccessEnvelopeProxy createProxy() {
+ SE createProxy() {
+ return new SE(this);
+ }
+
+ @Override
+ SuccessEnvelopeProxy legacyProxy() {
return new SuccessEnvelopeProxy(this);
}
+
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
-
-final class SuccessEnvelopeProxy extends AbstractResponseEnvelopeProxy<RequestSuccess<?, ?>> {
- @Serial
+final class SuccessEnvelopeProxy extends AbstractResponseEnvelopeProxy<RequestSuccess<?, ?>, SuccessEnvelope>
+ implements SuccessEnvelope.SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
SuccessEnvelopeProxy(final SuccessEnvelope envelope) {
super(envelope);
}
-
- @Override
- ResponseEnvelope<RequestSuccess<?, ?>> createEnvelope(final RequestSuccess<?, ?> message, final long sessionId,
- final long txSequence, final long executionTimeNanos) {
- return new SuccessEnvelope(message, sessionId, txSequence, executionTimeNanos);
- }
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.access.concepts;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Serialization proxy for {@link TransactionIdentifier}.
+ */
+final class TI implements TransactionIdentifier.SerialForm {
+ @java.io.Serial
+ private static final long serialVersionUID = 1L;
+
+ private TransactionIdentifier identifier;
+
+ @SuppressWarnings("checkstyle:RedundantModifier")
+ public TI() {
+ // for Externalizable
+ }
+
+ TI(final TransactionIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
+ }
+
+ @Override
+ public TransactionIdentifier identifier() {
+ return verifyNotNull(identifier);
+ }
+
+ @Override
+ public void setIdentifier(final TransactionIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
+ }
+
+ @Override
+ public Object readResolve() {
+ return identifier();
+ }
+}
*/
package org.opendaylight.controller.cluster.access.concepts;
+import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import java.io.DataInput;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
-import java.io.Serial;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
import org.opendaylight.yangtools.concepts.WritableObjects;
* Globally-unique identifier of a transaction.
*/
public final class TransactionIdentifier implements WritableIdentifier {
- private static final class Proxy implements Externalizable {
- @Serial
+ interface SerialForm extends Externalizable {
+ @NonNull TransactionIdentifier identifier();
+
+ void setIdentifier(@NonNull TransactionIdentifier identifier);
+
+ @java.io.Serial
+ Object readResolve();
+
+ @Override
+ default void readExternal(final ObjectInput in) throws IOException {
+ setIdentifier(new TransactionIdentifier(LocalHistoryIdentifier.readFrom(in), WritableObjects.readLong(in)));
+ }
+
+ @Override
+ default void writeExternal(final ObjectOutput out) throws IOException {
+ final var id = identifier();
+ id.getHistoryId().writeTo(out);
+ WritableObjects.writeLong(out, id.getTransactionId());
+ }
+ }
+
+ private static final class Proxy implements SerialForm {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private LocalHistoryIdentifier historyId;
- private long transactionId;
+ private TransactionIdentifier identifier;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
// be able to create instances via reflection.
// For Externalizable
}
- Proxy(final LocalHistoryIdentifier historyId, final long transactionId) {
- this.historyId = requireNonNull(historyId);
- this.transactionId = transactionId;
+ Proxy(final TransactionIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
}
@Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- historyId.writeTo(out);
- WritableObjects.writeLong(out, transactionId);
+ public @NonNull TransactionIdentifier identifier() {
+ return verifyNotNull(identifier);
}
@Override
- public void readExternal(final ObjectInput in) throws IOException {
- historyId = LocalHistoryIdentifier.readFrom(in);
- transactionId = WritableObjects.readLong(in);
+ public void setIdentifier(final TransactionIdentifier identifier) {
+ this.identifier = requireNonNull(identifier);
}
- @Serial
- private Object readResolve() {
- return new TransactionIdentifier(historyId, transactionId);
+ @Override
+ public Object readResolve() {
+ return identifier();
}
}
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull LocalHistoryIdentifier historyId;
return toShortString();
}
- @Serial
+ @java.io.Serial
private Object writeReplace() {
- return new Proxy(historyId, transactionId);
+ return new Proxy(this);
}
}
*/
package org.opendaylight.controller.cluster.access.concepts;
-import java.io.Serial;
-
/**
* General error raised when the recipient of a {@link Request} determines that it does not know how to handle
* the request.
*/
public final class UnsupportedRequestException extends RequestException {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
public UnsupportedRequestException(final Request<?, ?> request) {
@Test
public void cloneAsVersionTest() {
- final ConnectClientSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getAlternates(), clone.getAlternates());
+ assertEquals(OBJECT.getBackend(), clone.getBackend());
+ assertEquals(OBJECT.getDataTree(), clone.getDataTree());
+ assertEquals(OBJECT.getMaxMessages(), clone.getMaxMessages());
}
@Test
@Test
public void cloneAsVersionTest() {
- assertEquals(OBJECT, OBJECT.cloneAsVersion(ABIVersion.BORON));
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getExists(), clone.getExists());
}
@Test
*/
package org.opendaylight.controller.cluster.access.commands;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.opendaylight.controller.cluster.access.ABIVersion;
@Test
public void cloneAsVersionTest() {
- final LocalHistoryFailure clone = OBJECT.cloneAsVersion(ABIVersion.current());
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getCause(), clone.getCause());
}
}
\ No newline at end of file
@Test
public void cloneAsVersionTest() {
- assertEquals(OBJECT, OBJECT.cloneAsVersion(ABIVersion.BORON));
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getReplyTo(), clone.getReplyTo());
+ assertEquals(OBJECT.getPersistenceProtocol(), clone.getPersistenceProtocol());
}
@Override
@Test
public void cloneAsVersionTest() {
- assertEquals(OBJECT, OBJECT.cloneAsVersion(ABIVersion.BORON));
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getReplyTo(), clone.getReplyTo());
+ assertEquals(OBJECT.getModifications(), clone.getModifications());
+ assertEquals(OBJECT.getPersistenceProtocol(), clone.getPersistenceProtocol());
}
@Override
@Test
public void cloneAsVersionTest() {
- final ReadTransactionSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getData(), clone.getData());
}
@Override
@Test
public void cloneAsVersionTest() {
- final ReadTransactionSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getData(), clone.getData());
}
@Override
@Test
public void cloneAsVersionTest() {
- assertEquals(OBJECT, OBJECT.cloneAsVersion(ABIVersion.BORON));
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getReplyTo(), clone.getReplyTo());
}
@Override
@Test
public void cloneAsVersionTest() {
- final SkipTransactionsResponse clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
}
}
\ No newline at end of file
@Test
public void cloneAsVersionTest() {
- assertEquals(OBJECT, OBJECT.cloneAsVersion(ABIVersion.BORON));
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getReplyTo(), clone.getReplyTo());
}
@Override
@Test
public void cloneAsVersionTest() {
- final TransactionAbortSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
}
}
\ No newline at end of file
*/
package org.opendaylight.controller.cluster.access.commands;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.opendaylight.controller.cluster.access.ABIVersion;
@Test
public void cloneAsVersionTest() {
- final TransactionCanCommitSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
}
}
\ No newline at end of file
@Test
public void cloneAsVersionTest() {
- final TransactionCommitSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
}
}
@Test
public void cloneAsVersionTest() {
- assertEquals(OBJECT, OBJECT.cloneAsVersion(ABIVersion.BORON));
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getReplyTo(), clone.getReplyTo());
}
@Override
*/
package org.opendaylight.controller.cluster.access.commands;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.opendaylight.controller.cluster.access.ABIVersion;
@Test
public void cloneAsVersionTest() {
- final TransactionFailure clone = OBJECT.cloneAsVersion(ABIVersion.current());
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getCause(), clone.getCause());
}
}
\ No newline at end of file
@Test
public void cloneAsVersionTest() {
- assertEquals(OBJECT, OBJECT.cloneAsVersion(ABIVersion.BORON));
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getReplyTo(), clone.getReplyTo());
}
@Override
@Test
public void cloneAsVersionTest() {
- final TransactionPreCommitSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
}
}
\ No newline at end of file
@Test
public void cloneAsVersionTest() {
- assertEquals(OBJECT, OBJECT.cloneAsVersion(ABIVersion.BORON));
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(OBJECT.getReplyTo(), clone.getReplyTo());
}
@Override
@Test
public void cloneAsVersionTest() {
- final TransactionPurgeResponse clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- assertEquals(OBJECT, clone);
+ final var clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
}
}
\ No newline at end of file
import java.io.DataInput;
import java.io.IOException;
-import java.io.Serial;
import org.apache.commons.lang.SerializationUtils;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
}
private static class MockRequestFailureProxy extends AbstractRequestFailureProxy<WritableIdentifier, MockFailure> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 5015515628523887221L;
@SuppressWarnings("checkstyle:RedundantModifier")
}
@Override
- protected MockFailure createFailure(final WritableIdentifier target, final long sequence,
- final RequestException failureCause) {
+ public MockFailure createFailure(final WritableIdentifier target, final long sequence,
+ final RequestException failureCause) {
return new MockFailure(target, failureCause, sequence);
}
@Override
- protected WritableIdentifier readTarget(final DataInput in) throws IOException {
+ public WritableIdentifier readTarget(final DataInput in) throws IOException {
return TransactionIdentifier.readFrom(in);
}
}
private static class MockFailure extends RequestFailure<WritableIdentifier, MockFailure> {
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
MockFailure(final WritableIdentifier target, final RequestException cause, final long sequence) {
@Override
protected TransmitQueue.Transmitting createQueue() {
doReturn(false).when(mockMessageSlicer).slice(any());
- backendInfo = new BackendInfo(probe.ref(), "test", 0L, ABIVersion.BORON, 3);
+ backendInfo = new BackendInfo(probe.ref(), "test", 0L, ABIVersion.current(), 3);
return new TransmitQueue.Transmitting(new TransmitQueue.Halted(0), 0, backendInfo, now(), mockMessageSlicer);
}
Code Review / controller.git / commitdiff