import java.io.DataOutput;
import java.io.IOException;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeStreamVersion;
import org.opendaylight.yangtools.concepts.WritableObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* Version which is older than any other version. This version exists purely for testing purposes.
*/
@VisibleForTesting
- TEST_PAST_VERSION(0),
+ TEST_PAST_VERSION(0) {
+ @Override
+ public NormalizedNodeStreamVersion getStreamVersion() {
+ throw new UnsupportedOperationException();
+ }
+ },
/**
* Initial ABI version, as shipped with Boron Simultaneous release.
*/
// We seed the initial version to be the same as DataStoreVersions.BORON-VERSION for compatibility reasons.
- BORON(5),
+ BORON(5) {
+ @Override
+ public NormalizedNodeStreamVersion getStreamVersion() {
+ return NormalizedNodeStreamVersion.LITHIUM;
+ }
+ },
+
+ /**
+ * Revised ABI version. The messages remain the same as {@link #BORON}, but messages bearing QNames in any shape
+ * are using {@link NormalizedNodeStreamVersion#SODIUM}, which improves encoding.
+ */
+ SODIUM(6) {
+ @Override
+ public NormalizedNodeStreamVersion getStreamVersion() {
+ return NormalizedNodeStreamVersion.SODIUM;
+ }
+ },
/**
* Version which is newer than any other version. This version exists purely for testing purposes.
*/
@VisibleForTesting
- TEST_FUTURE_VERSION(65535);
+ TEST_FUTURE_VERSION(65535) {
+ @Override
+ public NormalizedNodeStreamVersion getStreamVersion() {
+ throw new UnsupportedOperationException();
+ }
+ };
private static final Logger LOG = LoggerFactory.getLogger(ABIVersion.class);
* @return Current {@link ABIVersion}
*/
public static @NonNull ABIVersion current() {
- return BORON;
+ return SODIUM;
}
/**
throw new PastVersionException(value, BORON);
case 5:
return BORON;
+ case 6:
+ return SODIUM;
default:
- throw new FutureVersionException(value, BORON);
+ throw new FutureVersionException(value, SODIUM);
}
}
out.writeShort(value);
}
+ /**
+ * Return the NormalizedNode stream version corresponding to this particular ABI.
+ *
+ * @return Stream Version to use for this ABI version
+ */
+ public abstract @NonNull NormalizedNodeStreamVersion getStreamVersion();
+
/**
* Read an {@link ABIVersion} from a {@link DataInput}. This method is provided for callers which do not have
* a recovery strategy for dealing with unsupported versions.
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataOutput;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputOutput;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeStreamVersion;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
abstract class AbstractReadPathTransactionRequestProxyV1<T extends AbstractReadPathTransactionRequest<T>>
extends AbstractReadTransactionRequestProxyV1<T> {
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 = NormalizedNodeInputOutput.newDataOutput(out)) {
+ try (NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(out, streamVersion)) {
nnout.writeYangInstanceIdentifier(path);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
+import static java.util.Objects.requireNonNull;
+
import akka.actor.ActorRef;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import java.io.IOException;
import java.io.ObjectInput;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataInput;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataOutput;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputOutput;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeStreamVersion;
/**
* Externalizable proxy for use with {@link ExistsTransactionRequest}. It implements the initial (Boron) serialization
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.
ModifyTransactionRequestProxyV1(final ModifyTransactionRequest request) {
super(request);
- this.modifications = Preconditions.checkNotNull(request.getModifications());
+ this.modifications = requireNonNull(request.getModifications());
this.protocol = request.getPersistenceProtocol();
+ this.streamVersion = request.getVersion().getStreamVersion();
}
@Override
out.writeByte(PersistenceProtocol.byteValue(protocol.orElse(null)));
out.writeInt(modifications.size());
if (!modifications.isEmpty()) {
- try (NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(out)) {
+ try (NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(out, streamVersion)) {
for (TransactionModification op : modifications) {
op.writeTo(nnout);
}
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataOutput;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputOutput;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeStreamVersion;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
*/
final class ReadTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ReadTransactionSuccess> {
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.
ReadTransactionSuccessProxyV1(final ReadTransactionSuccess request) {
super(request);
this.data = request.getData();
+ this.streamVersion = request.getVersion().getStreamVersion();
}
@Override
if (data.isPresent()) {
out.writeBoolean(true);
- try (NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(out)) {
+ try (NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(out, streamVersion)) {
nnout.writeNormalizedNode(data.get());
}
} else {
switch (toVersion) {
case BORON:
+ case SODIUM:
return verifyNotNull(cloneAsVersion(toVersion));
case TEST_PAST_VERSION:
case TEST_FUTURE_VERSION:
*/
package org.opendaylight.controller.cluster.access.commands;
-import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
import org.junit.Test;
import org.opendaylight.controller.cluster.access.ABIVersion;
public class LocalHistorySuccessTest extends AbstractRequestSuccessTest<LocalHistorySuccess> {
-
- private static final LocalHistorySuccess OBJECT = new LocalHistorySuccess(
- HISTORY_IDENTIFIER, 0);
+ private static final LocalHistorySuccess OBJECT = new LocalHistorySuccess(HISTORY_IDENTIFIER, 0);
@Override
protected LocalHistorySuccess object() {
@Test
public void cloneAsVersionTest() {
final LocalHistorySuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- Assert.assertEquals(OBJECT.getSequence(), clone.getSequence());
- Assert.assertEquals(OBJECT.getTarget(), clone.getTarget());
- Assert.assertEquals(OBJECT.getVersion(), clone.getVersion());
+ assertEquals(ABIVersion.BORON, clone.getVersion());
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
}
@Override
protected void doAdditionalAssertions(final Object deserialize) {
- Assert.assertTrue(deserialize instanceof LocalHistorySuccess);
+ assertTrue(deserialize instanceof LocalHistorySuccess);
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
-import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
import org.junit.Test;
import org.opendaylight.controller.cluster.access.ABIVersion;
public class ModifyTransactionSuccessTest extends AbstractTransactionSuccessTest<ModifyTransactionSuccess> {
- private static final ModifyTransactionSuccess OBJECT = new ModifyTransactionSuccess(
- TRANSACTION_IDENTIFIER, 0);
+ private static final ModifyTransactionSuccess OBJECT = new ModifyTransactionSuccess(TRANSACTION_IDENTIFIER, 0);
@Override
protected ModifyTransactionSuccess object() {
@Test
public void cloneAsVersionTest() {
final ModifyTransactionSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- Assert.assertEquals(OBJECT.getVersion(), clone.getVersion());
- Assert.assertEquals(OBJECT.getSequence(), clone.getSequence());
- Assert.assertEquals(OBJECT.getTarget(), clone.getTarget());
+ assertEquals(ABIVersion.BORON, clone.getVersion());
+ assertEquals(OBJECT.getSequence(), clone.getSequence());
+ assertEquals(OBJECT.getTarget(), clone.getTarget());
}
@Override
protected void doAdditionalAssertions(final Object deserialize) {
- Assert.assertTrue(deserialize instanceof ModifyTransactionSuccess);
+ assertTrue(deserialize instanceof ModifyTransactionSuccess);
}
}
\ No newline at end of file