summary |
shortlog |
log |
commit | commitdiff |
review |
tree
raw |
patch |
inline | side by side (from parent 1:
35dfbc0)
Thread-local streams have little control over the version being
used, as the stream is allocated all over the place.
This model cannot function without explicit setup, which is used
by CompositeModification. This patch migrates CompositeModification
to use a new NormalizedNodeDataInput-based interface, so
thread-locals become obsolete.
JIRA: CONTROLLER-1888
Change-Id: I1111be5d6fc8c0129fb72232c3e713004068f152
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
private YangInstanceIdentifier path;
private short version;
private YangInstanceIdentifier path;
private short version;
- protected AbstractModification(short version) {
+ protected AbstractModification(final short version) {
this.version = version;
}
this.version = version;
}
- protected AbstractModification(YangInstanceIdentifier path) {
+ protected AbstractModification(final short version, final YangInstanceIdentifier path) {
+ this.path = path;
+ this.version = version;
+ }
+
+ protected AbstractModification(final YangInstanceIdentifier path) {
- protected void setPath(YangInstanceIdentifier path) {
+ protected void setPath(final YangInstanceIdentifier path) {
package org.opendaylight.controller.cluster.datastore.modification;
package org.opendaylight.controller.cluster.datastore.modification;
+import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
+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.SerializationUtils;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.SerializationUtils;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
this(DataStoreVersions.CURRENT_VERSION);
}
this(DataStoreVersions.CURRENT_VERSION);
}
- public DeleteModification(short version) {
+ public DeleteModification(final short version) {
- public DeleteModification(YangInstanceIdentifier path) {
+ public DeleteModification(final YangInstanceIdentifier path) {
+ DeleteModification(final short version, final YangInstanceIdentifier path) {
+ super(version, path);
+ }
+
- public void apply(DOMStoreWriteTransaction transaction) {
+ public void apply(final DOMStoreWriteTransaction transaction) {
transaction.delete(getPath());
}
@Override
transaction.delete(getPath());
}
@Override
- public void apply(DataTreeModification transaction) {
+ public void apply(final DataTreeModification transaction) {
transaction.delete(getPath());
}
transaction.delete(getPath());
}
- public void readExternal(ObjectInput in) {
+ public void readExternal(final ObjectInput in) {
setPath(SerializationUtils.deserializePath(in));
}
@Override
setPath(SerializationUtils.deserializePath(in));
}
@Override
- public void writeExternal(ObjectOutput out) {
+ public void writeExternal(final ObjectOutput out) {
SerializationUtils.serializePath(getPath(), out);
}
SerializationUtils.serializePath(getPath(), out);
}
- public static DeleteModification fromStream(ObjectInput in, short version) {
- DeleteModification mod = new DeleteModification(version);
- mod.readExternal(in);
- return mod;
+ @Override
+ public void writeTo(final NormalizedNodeDataOutput out) throws IOException {
+ out.writeYangInstanceIdentifier(getPath());
+ }
+
+ public static DeleteModification fromStream(final NormalizedNodeDataInput in, final short version)
+ throws IOException {
+ return new DeleteModification(version, in.readYangInstanceIdentifier());
package org.opendaylight.controller.cluster.datastore.modification;
package org.opendaylight.controller.cluster.datastore.modification;
-import java.io.ObjectInput;
+import java.io.IOException;
import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataInput;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
this(DataStoreVersions.CURRENT_VERSION);
}
this(DataStoreVersions.CURRENT_VERSION);
}
- public MergeModification(short version) {
+ public MergeModification(final short version) {
+ MergeModification(final short version, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ super(version, path, data);
+ }
+
@Override
public void apply(final DOMStoreWriteTransaction transaction) {
transaction.merge(getPath(), getData());
@Override
public void apply(final DOMStoreWriteTransaction transaction) {
transaction.merge(getPath(), getData());
- public static MergeModification fromStream(ObjectInput in, short version) {
- MergeModification mod = new MergeModification(version);
- mod.readExternal(in);
- return mod;
+ public static MergeModification fromStream(final NormalizedNodeDataInput in, final short version)
+ throws IOException {
+ final NormalizedNode<?, ?> node = in.readNormalizedNode();
+ final YangInstanceIdentifier path = in.readYangInstanceIdentifier();
+ return new MergeModification(version, path, node);
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataOutput;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
@Override
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
@Override
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
+
+ void writeTo(NormalizedNodeDataOutput out) throws IOException;
import java.util.List;
import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
import org.opendaylight.controller.cluster.datastore.messages.VersionedExternalizableMessage;
import java.util.List;
import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
import org.opendaylight.controller.cluster.datastore.messages.VersionedExternalizableMessage;
+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.NormalizedNodeInputOutput;
-import org.opendaylight.controller.cluster.datastore.node.utils.stream.SerializationUtils;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
this(DataStoreVersions.CURRENT_VERSION);
}
this(DataStoreVersions.CURRENT_VERSION);
}
- public MutableCompositeModification(short version) {
+ public MutableCompositeModification(final short version) {
super(version);
}
@Override
super(version);
}
@Override
- public void apply(DOMStoreWriteTransaction transaction) {
+ public void apply(final DOMStoreWriteTransaction transaction) {
for (Modification modification : modifications) {
modification.apply(transaction);
}
}
@Override
for (Modification modification : modifications) {
modification.apply(transaction);
}
}
@Override
- public void apply(DataTreeModification transaction) {
+ public void apply(final DataTreeModification transaction) {
for (Modification modification : modifications) {
modification.apply(transaction);
}
for (Modification modification : modifications) {
modification.apply(transaction);
}
*
* @param modification the modification to add.
*/
*
* @param modification the modification to add.
*/
- public void addModification(Modification modification) {
+ public void addModification(final Modification modification) {
Preconditions.checkNotNull(modification);
modifications.add(modification);
}
Preconditions.checkNotNull(modification);
modifications.add(modification);
}
- public void addModifications(Iterable<Modification> newMods) {
+ public void addModifications(final Iterable<Modification> newMods) {
for (Modification mod : newMods) {
addModification(mod);
}
for (Modification mod : newMods) {
addModification(mod);
}
- public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
super.readExternal(in);
int size = in.readInt();
super.readExternal(in);
int size = in.readInt();
-
- if (size > 1) {
- SerializationUtils.REUSABLE_READER_TL.set(NormalizedNodeInputOutput.newDataInputWithoutValidation(in));
- }
-
- try {
+ if (size > 0) {
+ final NormalizedNodeDataInput input = NormalizedNodeInputOutput.newDataInputWithoutValidation(in);
for (int i = 0; i < size; i++) {
byte type = in.readByte();
switch (type) {
case Modification.WRITE:
for (int i = 0; i < size; i++) {
byte type = in.readByte();
switch (type) {
case Modification.WRITE:
- modifications.add(WriteModification.fromStream(in, getVersion()));
+ modifications.add(WriteModification.fromStream(input, getVersion()));
break;
case Modification.MERGE:
break;
case Modification.MERGE:
- modifications.add(MergeModification.fromStream(in, getVersion()));
+ modifications.add(MergeModification.fromStream(input, getVersion()));
break;
case Modification.DELETE:
break;
case Modification.DELETE:
- modifications.add(DeleteModification.fromStream(in, getVersion()));
+ modifications.add(DeleteModification.fromStream(input, getVersion()));
break;
default:
break;
}
}
break;
default:
break;
}
}
- } finally {
- SerializationUtils.REUSABLE_READER_TL.remove();
- public void writeExternal(ObjectOutput out) throws IOException {
+ public void writeExternal(final ObjectOutput out) throws IOException {
super.writeExternal(out);
super.writeExternal(out);
- out.writeInt(modifications.size());
-
- if (modifications.size() > 1) {
- SerializationUtils.REUSABLE_WRITER_TL.set(NormalizedNodeInputOutput.newDataOutput(out));
- }
-
- try {
- for (Modification mod: modifications) {
- out.writeByte(mod.getType());
- mod.writeExternal(out);
+ final int size = modifications.size();
+ out.writeInt(size);
+ if (size > 0) {
+ try (NormalizedNodeDataOutput stream = NormalizedNodeInputOutput.newDataOutput(out)) {
+ for (Modification mod : modifications) {
+ out.writeByte(mod.getType());
+ mod.writeTo(stream);
+ }
- } finally {
- SerializationUtils.REUSABLE_WRITER_TL.remove();
- public static MutableCompositeModification fromSerializable(Object serializable) {
+ public static MutableCompositeModification fromSerializable(final Object serializable) {
Preconditions.checkArgument(serializable instanceof MutableCompositeModification);
return (MutableCompositeModification)serializable;
}
Preconditions.checkArgument(serializable instanceof MutableCompositeModification);
return (MutableCompositeModification)serializable;
}
+
+ @Override
+ public void writeTo(final NormalizedNodeDataOutput out) throws IOException {
+ throw new UnsupportedOperationException();
+ }
package org.opendaylight.controller.cluster.datastore.modification;
package org.opendaylight.controller.cluster.datastore.modification;
+import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
+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.SerializationUtils;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.SerializationUtils.Applier;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.SerializationUtils;
import org.opendaylight.controller.cluster.datastore.node.utils.stream.SerializationUtils.Applier;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
this(DataStoreVersions.CURRENT_VERSION);
}
this(DataStoreVersions.CURRENT_VERSION);
}
- public WriteModification(short version) {
+ public WriteModification(final short version) {
+ WriteModification(final short version, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ super(version, path);
+ this.data = data;
+ }
+
public WriteModification(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
super(path);
this.data = data;
public WriteModification(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
super(path);
this.data = data;
- public void readExternal(ObjectInput in) {
+ public void readExternal(final ObjectInput in) {
SerializationUtils.deserializePathAndNode(in, this, APPLIER);
}
@Override
SerializationUtils.deserializePathAndNode(in, this, APPLIER);
}
@Override
- public void writeExternal(ObjectOutput out) {
+ public void writeExternal(final ObjectOutput out) {
SerializationUtils.serializePathAndNode(getPath(), data, out);
}
SerializationUtils.serializePathAndNode(getPath(), data, out);
}
- public static WriteModification fromStream(ObjectInput in, short version) {
- WriteModification mod = new WriteModification(version);
- mod.readExternal(in);
- return mod;
+ public static WriteModification fromStream(final NormalizedNodeDataInput in, final short version)
+ throws IOException {
+ final NormalizedNode<?, ?> node = in.readNormalizedNode();
+ final YangInstanceIdentifier path = in.readYangInstanceIdentifier();
+ return new WriteModification(version, path, node);
+ }
+
+ public void writeTo(final NormalizedNodeDataOutput out) throws IOException {
+ // FIXME: this should be inverted, as the path helps receivers in establishment of context
+ out.writeNormalizedNode(data);
+ out.writeYangInstanceIdentifier(getPath());
}
private static final Applier<WriteModification> APPLIER = (instance, path, node) -> {
}
private static final Applier<WriteModification> APPLIER = (instance, path, node) -> {