--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, 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 akka.actor.ActorRef;
+import com.google.common.annotations.Beta;
+import com.google.common.base.MoreObjects.ToStringHelper;
+import com.google.common.base.Preconditions;
+import javax.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;
+
+/**
+ * Abstract base class for {@link TransactionRequest}s accessing data as visible in the isolated context of a particular
+ * transaction. The path of the data being accessed is returned via {@link #getPath()}.
+ *
+ * <p>
+ * This class is visible outside of this package for the purpose of allowing common instanceof checks
+ * and simplified codepaths.
+ *
+ * @author Robert Varga
+ *
+ * @param <T> Message type
+ */
+@Beta
+public abstract class AbstractReadPathTransactionRequest<T extends AbstractReadPathTransactionRequest<T>>
+ extends AbstractReadTransactionRequest<T> {
+ private static final long serialVersionUID = 1L;
+ private final YangInstanceIdentifier path;
+
+ AbstractReadPathTransactionRequest(final TransactionIdentifier identifier, final long sequence,
+ final ActorRef replyTo, final YangInstanceIdentifier path, final boolean snapshotOnly) {
+ super(identifier, sequence, replyTo, snapshotOnly);
+ this.path = Preconditions.checkNotNull(path);
+ }
+
+ AbstractReadPathTransactionRequest(final T request, final ABIVersion version) {
+ super(request, version);
+ this.path = request.getPath();
+ }
+
+ @Nonnull
+ public final YangInstanceIdentifier getPath() {
+ return path;
+ }
+
+ @Override
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper).add("path", path);
+ }
+
+ @Override
+ protected abstract AbstractReadTransactionRequestProxyV1<T> externalizableProxy(ABIVersion version);
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, 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 akka.actor.ActorRef;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+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.yangtools.yang.data.api.YangInstanceIdentifier;
+
+/**
+ * Abstract base class for serialization proxies associated with {@link AbstractReadTransactionRequest}s. It implements
+ * the initial (Boron) serialization format.
+ *
+ * @author Robert Varga
+ *
+ * @param <T> Message type
+ */
+abstract class AbstractReadPathTransactionRequestProxyV1<T extends AbstractReadPathTransactionRequest<T>>
+ extends AbstractReadTransactionRequestProxyV1<T> {
+ private static final long serialVersionUID = 1L;
+ private YangInstanceIdentifier path;
+
+ protected AbstractReadPathTransactionRequestProxyV1() {
+ // For Externalizable
+ }
+
+ AbstractReadPathTransactionRequestProxyV1(final T request) {
+ super(request);
+ path = request.getPath();
+ }
+
+ @Override
+ public final void writeExternal(final ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+ try (NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(out)) {
+ nnout.writeYangInstanceIdentifier(path);
+ }
+ }
+
+ @Override
+ public final void readExternal(final ObjectInput in) throws ClassNotFoundException, IOException {
+ super.readExternal(in);
+ path = NormalizedNodeInputOutput.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.annotations.Beta;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
-import javax.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;
/**
- * Abstract base class for {@link TransactionRequest}s accessing data as visible in the isolated context of a particular
- * transaction. The path of the data being accessed is returned via {@link #getPath()}.
+ * Abstract base class for {@link TransactionRequest}s accessing transaction state without modifying it.
*
* <p>
* This class is visible outside of this package for the purpose of allowing common instanceof checks
public abstract class AbstractReadTransactionRequest<T extends AbstractReadTransactionRequest<T>>
extends TransactionRequest<T> {
private static final long serialVersionUID = 1L;
- private final YangInstanceIdentifier path;
+
private final boolean snapshotOnly;
AbstractReadTransactionRequest(final TransactionIdentifier identifier, final long sequence, final ActorRef replyTo,
- final YangInstanceIdentifier path, final boolean snapshotOnly) {
+ final boolean snapshotOnly) {
super(identifier, sequence, replyTo);
- this.path = Preconditions.checkNotNull(path);
this.snapshotOnly = snapshotOnly;
}
AbstractReadTransactionRequest(final T request, final ABIVersion version) {
super(request, version);
- this.path = request.getPath();
this.snapshotOnly = request.isSnapshotOnly();
}
- @Nonnull
- public final YangInstanceIdentifier getPath() {
- return path;
- }
-
public final boolean isSnapshotOnly() {
return snapshotOnly;
}
@Override
protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
- return super.addToStringAttributes(toStringHelper).add("path", path);
+ return super.addToStringAttributes(toStringHelper).add("snapshotOnly", snapshotOnly);
}
@Override
import java.io.ObjectInput;
import java.io.ObjectOutput;
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.yangtools.yang.data.api.YangInstanceIdentifier;
/**
* Abstract base class for serialization proxies associated with {@link AbstractReadTransactionRequest}s. It implements
abstract class AbstractReadTransactionRequestProxyV1<T extends AbstractReadTransactionRequest<T>>
extends AbstractTransactionRequestProxy<T> {
private static final long serialVersionUID = 1L;
- private YangInstanceIdentifier path;
private boolean snapshotOnly;
protected AbstractReadTransactionRequestProxyV1() {
AbstractReadTransactionRequestProxyV1(final T request) {
super(request);
- path = request.getPath();
snapshotOnly = request.isSnapshotOnly();
}
@Override
- public final void writeExternal(final ObjectOutput out) throws IOException {
+ public void writeExternal(final ObjectOutput out) throws IOException {
super.writeExternal(out);
- try (NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(out)) {
- nnout.writeYangInstanceIdentifier(path);
- }
out.writeBoolean(snapshotOnly);
}
@Override
- public final void readExternal(final ObjectInput in) throws ClassNotFoundException, IOException {
+ public void readExternal(final ObjectInput in) throws ClassNotFoundException, IOException {
super.readExternal(in);
- path = NormalizedNodeInputOutput.newDataInput(in).readYangInstanceIdentifier();
snapshotOnly = in.readBoolean();
}
@Override
protected final T createRequest(final TransactionIdentifier target, final long sequence, final ActorRef replyTo) {
- return createReadRequest(target, sequence, replyTo, path, snapshotOnly);
+ return createReadRequest(target, sequence, replyTo, snapshotOnly);
}
- abstract T createReadRequest(TransactionIdentifier target, long sequence, ActorRef replyTo,
- YangInstanceIdentifier requestPath, boolean snapshotOnly);
+ abstract T createReadRequest(TransactionIdentifier target, long sequence, ActorRef replyTo, boolean snapshotOnly);
}
* @author Robert Varga
*/
@Beta
-public final class ExistsTransactionRequest extends AbstractReadTransactionRequest<ExistsTransactionRequest> {
+public final class ExistsTransactionRequest extends AbstractReadPathTransactionRequest<ExistsTransactionRequest> {
private static final long serialVersionUID = 1L;
public ExistsTransactionRequest(@Nonnull final TransactionIdentifier identifier, final long sequence,
*
* @author Robert Varga
*/
-final class ExistsTransactionRequestProxyV1 extends AbstractReadTransactionRequestProxyV1<ExistsTransactionRequest> {
+final class ExistsTransactionRequestProxyV1 extends
+ AbstractReadPathTransactionRequestProxyV1<ExistsTransactionRequest> {
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
}
@Override
- ExistsTransactionRequest createReadRequest(final TransactionIdentifier target, final long sequence,
+ 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);
}
*
* @author Robert Varga
*/
-public final class IncrementTransactionSequenceRequest extends TransactionRequest<IncrementTransactionSequenceRequest> {
+public final class IncrementTransactionSequenceRequest extends
+ AbstractReadTransactionRequest<IncrementTransactionSequenceRequest> {
private static final long serialVersionUID = 1L;
private final long increment;
public IncrementTransactionSequenceRequest(final TransactionIdentifier identifier, final long sequence,
- final ActorRef replyTo, final long increment) {
- super(identifier, sequence, replyTo);
+ final ActorRef replyTo, final boolean snapshotOnly, final long increment) {
+ super(identifier, sequence, replyTo, snapshotOnly);
Preconditions.checkArgument(increment >= 0);
this.increment = increment;
}
+ /**
+ * Return the sequence increment beyond this request's sequence.
+ *
+ * @return Sequence increment, guaranteed to be non-negative.
+ */
+ public long getIncrement() {
+ return increment;
+ }
+
@Override
protected IncrementTransactionSequenceRequestProxyV1 externalizableProxy(final ABIVersion version) {
return new IncrementTransactionSequenceRequestProxyV1(this);
protected IncrementTransactionSequenceRequest cloneAsVersion(final ABIVersion targetVersion) {
return this;
}
-
- /**
- * Return the sequence increment beyond this request's sequence.
- *
- * @return Sequence increment, guaranteed to be non-negative.
- */
- public long getIncrement() {
- return increment;
- }
}
import org.opendaylight.yangtools.concepts.WritableObjects;
final class IncrementTransactionSequenceRequestProxyV1
- extends AbstractTransactionRequestProxy<IncrementTransactionSequenceRequest> {
+ extends AbstractReadTransactionRequestProxyV1<IncrementTransactionSequenceRequest> {
private long increment;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
}
@Override
- protected IncrementTransactionSequenceRequest createRequest(final TransactionIdentifier target, final long sequence,
- final ActorRef replyToActor) {
- return new IncrementTransactionSequenceRequest(target, sequence, replyToActor, increment);
+ IncrementTransactionSequenceRequest createReadRequest(final TransactionIdentifier target, final long sequence,
+ final ActorRef replyToActor, final boolean snapshotOnly) {
+ return new IncrementTransactionSequenceRequest(target, sequence, replyToActor, snapshotOnly, increment);
}
}
* @author Robert Varga
*/
@Beta
-public final class ReadTransactionRequest extends AbstractReadTransactionRequest<ReadTransactionRequest> {
+public final class ReadTransactionRequest extends AbstractReadPathTransactionRequest<ReadTransactionRequest> {
private static final long serialVersionUID = 1L;
public ReadTransactionRequest(@Nonnull final TransactionIdentifier identifier, final long sequence,
*
* @author Robert Varga
*/
-final class ReadTransactionRequestProxyV1 extends AbstractReadTransactionRequestProxyV1<ReadTransactionRequest> {
+final class ReadTransactionRequestProxyV1 extends AbstractReadPathTransactionRequestProxyV1<ReadTransactionRequest> {
private static final long serialVersionUID = 1L;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
}
@Override
- ReadTransactionRequest createReadRequest(final TransactionIdentifier target, final long sequence,
+ 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 org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-public abstract class AbstractReadTransactionRequestTest<T extends AbstractReadTransactionRequest>
+public abstract class AbstractReadTransactionRequestTest<T extends AbstractReadPathTransactionRequest>
extends AbstractTransactionRequestTest {
protected static final YangInstanceIdentifier PATH = YangInstanceIdentifier.EMPTY;
protected static final boolean SNAPSHOT_ONLY = true;
Verify.verify(obj instanceof IncrementSequence);
final IncrementSequence increment = (IncrementSequence) obj;
successor.replayRequest(new IncrementTransactionSequenceRequest(getIdentifier(),
- increment.getSequence(), localActor(), increment.getDelta()), resp -> { }, now);
+ increment.getSequence(), localActor(), isSnapshotOnly(), increment.getDelta()), resp -> { },
+ now);
LOG.debug("Incrementing sequence {} to successor {}", obj, successor);
}
}
final IncrementTransactionSequenceRequest req = (IncrementTransactionSequenceRequest) request;
ensureFlushedBuider(optTicks);
enqueueRequest(new IncrementTransactionSequenceRequest(getIdentifier(), nextSequence(), localActor(),
- req.getIncrement()), callback, enqueuedTicks);
+ snapshotOnly, req.getIncrement()), callback, enqueuedTicks);
incrementSequence(req.getIncrement());
} else {
throw new IllegalArgumentException("Unhandled request {}" + request);
Code Review / controller.git / commitdiff