import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
import org.opendaylight.controller.cluster.access.concepts.RequestSuccess;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
/**
* Successful reply to an {@link ConnectClientRequest}. Client actor which initiated this connection should use
private final @NonNull List<ActorSelection> alternates;
@SuppressFBWarnings(value = "SE_BAD_FIELD", justification = "See justification above.")
- private final DataTree dataTree;
+ private final ReadOnlyDataTree dataTree;
private final @NonNull ActorRef backend;
private final int maxMessages;
ConnectClientSuccess(final ClientIdentifier target, final long sequence, final ActorRef backend,
- final List<ActorSelection> alternates, final Optional<DataTree> dataTree, final int maxMessages) {
+ final List<ActorSelection> alternates, final int maxMessages, final ReadOnlyDataTree dataTree) {
super(target, sequence);
this.backend = requireNonNull(backend);
this.alternates = ImmutableList.copyOf(alternates);
- this.dataTree = dataTree.orElse(null);
+ this.dataTree = dataTree;
checkArgument(maxMessages > 0, "Maximum messages has to be positive, not %s", maxMessages);
this.maxMessages = maxMessages;
}
public ConnectClientSuccess(final @NonNull ClientIdentifier target, final long sequence,
final @NonNull ActorRef backend, final @NonNull List<ActorSelection> alternates,
- final @NonNull DataTree dataTree, final int maxMessages) {
- this(target, sequence, backend, alternates, Optional.of(dataTree), maxMessages);
+ final @NonNull ReadOnlyDataTree dataTree, final int maxMessages) {
+ this(target, sequence, backend, alternates, maxMessages, requireNonNull(dataTree));
}
/**
return backend;
}
- public Optional<DataTree> getDataTree() {
+ public Optional<ReadOnlyDataTree> getDataTree() {
return Optional.ofNullable(dataTree);
}
import java.io.ObjectOutput;
import java.util.ArrayList;
import java.util.List;
-import java.util.Optional;
import org.opendaylight.controller.cluster.access.concepts.AbstractSuccessProxy;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
@Override
protected ConnectClientSuccess createSuccess(final ClientIdentifier target, final long sequence) {
- return new ConnectClientSuccess(target, sequence, backend, alternates, Optional.empty(), maxMessages);
+ return new ConnectClientSuccess(target, sequence, backend, alternates, maxMessages, null);
}
@Override
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
public class ConnectClientSuccessTest extends AbstractRequestSuccessTest<ConnectClientSuccess> {
@Test
public void testGetDataTree() {
- final DataTree tree = OBJECT.getDataTree().get();
+ final ReadOnlyDataTree tree = OBJECT.getDataTree().get();
Assert.assertEquals(TREE, tree);
}
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import akka.actor.ActorRef;
-import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import org.opendaylight.controller.cluster.access.concepts.Response;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
abstract class ProxyHistory implements Identifiable<LocalHistoryIdentifier> {
private abstract static class AbstractLocal extends ProxyHistory {
- private final DataTree dataTree;
+ private final ReadOnlyDataTree dataTree;
AbstractLocal(final AbstractClientHistory parent, final AbstractClientConnection<ShardBackendInfo> connection,
- final LocalHistoryIdentifier identifier, final DataTree dataTree) {
+ final LocalHistoryIdentifier identifier, final ReadOnlyDataTree dataTree) {
super(parent, connection, identifier);
- this.dataTree = Preconditions.checkNotNull(dataTree);
+ this.dataTree = requireNonNull(dataTree);
}
final DataTreeSnapshot takeSnapshot() {
private volatile LocalReadWriteProxyTransaction lastSealed;
Local(final AbstractClientHistory parent, final AbstractClientConnection<ShardBackendInfo> connection,
- final LocalHistoryIdentifier identifier, final DataTree dataTree) {
+ final LocalHistoryIdentifier identifier, final ReadOnlyDataTree dataTree) {
super(parent, connection, identifier, dataTree);
}
@Override
AbstractProxyTransaction doCreateTransactionProxy(final AbstractClientConnection<ShardBackendInfo> connection,
final TransactionIdentifier txId, final boolean snapshotOnly, final boolean isDone) {
- Preconditions.checkState(lastOpen == null, "Proxy %s has %s currently open", this, lastOpen);
+ checkState(lastOpen == null, "Proxy %s has %s currently open", this, lastOpen);
if (isDone) {
// Done transactions do not register on our radar on should not have any state associated.
@Override
void onTransactionSealed(final AbstractProxyTransaction tx) {
- Preconditions.checkState(tx.equals(lastOpen));
+ checkState(tx.equals(lastOpen));
lastSealed = lastOpen;
lastOpen = null;
}
private static final class LocalSingle extends AbstractLocal {
LocalSingle(final AbstractClientHistory parent, final AbstractClientConnection<ShardBackendInfo> connection,
- final LocalHistoryIdentifier identifier, final DataTree dataTree) {
+ final LocalHistoryIdentifier identifier, final ReadOnlyDataTree dataTree) {
super(parent, connection, identifier, dataTree);
}
private ProxyHistory(final AbstractClientHistory parent,
final AbstractClientConnection<ShardBackendInfo> connection, final LocalHistoryIdentifier identifier) {
- this.parent = Preconditions.checkNotNull(parent);
- this.connection = Preconditions.checkNotNull(connection);
- this.identifier = Preconditions.checkNotNull(identifier);
+ this.parent = requireNonNull(parent);
+ this.connection = requireNonNull(connection);
+ this.identifier = requireNonNull(identifier);
}
static ProxyHistory createClient(final AbstractClientHistory parent,
final AbstractClientConnection<ShardBackendInfo> connection, final LocalHistoryIdentifier identifier) {
- final Optional<DataTree> dataTree = connection.getBackendInfo().flatMap(ShardBackendInfo::getDataTree);
+ final Optional<ReadOnlyDataTree> dataTree = connection.getBackendInfo().flatMap(ShardBackendInfo::getDataTree);
return dataTree.isPresent() ? new Local(parent, connection, identifier, dataTree.get())
: new Remote(parent, connection, identifier);
}
static ProxyHistory createSingle(final AbstractClientHistory parent,
final AbstractClientConnection<ShardBackendInfo> connection,
final LocalHistoryIdentifier identifier) {
- final Optional<DataTree> dataTree = connection.getBackendInfo().flatMap(ShardBackendInfo::getDataTree);
+ final Optional<ReadOnlyDataTree> dataTree = connection.getBackendInfo().flatMap(ShardBackendInfo::getDataTree);
return dataTree.isPresent() ? new LocalSingle(parent, connection, identifier, dataTree.get())
: new RemoteSingle(parent, connection, identifier);
}
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import akka.actor.ActorRef;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedLong;
import java.util.Optional;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.controller.cluster.access.client.BackendInfo;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
/**
* Combined backend tracking. Aside from usual {@link BackendInfo}, this object also tracks the cookie assigned
* @author Robert Varga
*/
final class ShardBackendInfo extends BackendInfo {
- private final Optional<DataTree> dataTree;
+ private final Optional<ReadOnlyDataTree> dataTree;
private final UnsignedLong cookie;
ShardBackendInfo(final ActorRef actor, final long sessionId, final ABIVersion version, final String shardName,
- final UnsignedLong cookie, final Optional<DataTree> dataTree, final int maxMessages) {
+ final UnsignedLong cookie, final Optional<ReadOnlyDataTree> dataTree, final int maxMessages) {
super(actor, shardName, sessionId, version, maxMessages);
- this.cookie = Preconditions.checkNotNull(cookie);
- this.dataTree = Preconditions.checkNotNull(dataTree);
+ this.cookie = requireNonNull(cookie);
+ this.dataTree = requireNonNull(dataTree);
}
UnsignedLong getCookie() {
return cookie;
}
- Optional<DataTree> getDataTree() {
+ Optional<ReadOnlyDataTree> getDataTree() {
return dataTree;
}
LocalHistoryIdentifier brandHistory(final LocalHistoryIdentifier id) {
- Preconditions.checkArgument(id.getCookie() == 0, "History %s is already branded", id);
+ checkArgument(id.getCookie() == 0, "History %s is already branded", id);
return new LocalHistoryIdentifier(id.getClientId(), id.getHistoryId(), cookie.longValue());
}
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.concurrent.Future;
}
private void updateShardInfo(final String shardName, final PrimaryShardInfo primaryShardInfo) {
- final Optional<DataTree> maybeDataTree = primaryShardInfo.getLocalShardDataTree();
+ final Optional<ReadOnlyDataTree> maybeDataTree = primaryShardInfo.getLocalShardDataTree();
if (maybeDataTree.isPresent()) {
if (!knownLocal.containsKey(shardName)) {
LOG.debug("Shard {} resolved to local data tree - adding local factory", shardName);
* read-only manner.
* @return Transaction factory for local use.
*/
- protected abstract F factoryForShard(String shardName, ActorSelection shardLeader, DataTree dataTree);
+ protected abstract F factoryForShard(String shardName, ActorSelection shardLeader, ReadOnlyDataTree dataTree);
/**
* Callback invoked from child transactions to push any futures, which need to
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
/**
* Transaction chain instantiated on top of a locally-available DataTree. It does not instantiate
private static final Throwable ABORTED = new Throwable("Transaction aborted");
private final TransactionChainProxy parent;
private final ActorSelection leader;
- private final DataTree tree;
+ private final ReadOnlyDataTree tree;
- LocalTransactionChain(final TransactionChainProxy parent, final ActorSelection leader, final DataTree tree) {
+ LocalTransactionChain(final TransactionChainProxy parent, final ActorSelection leader,
+ final ReadOnlyDataTree tree) {
this.parent = requireNonNull(parent);
this.leader = requireNonNull(leader);
this.tree = requireNonNull(tree);
}
- DataTree getDataTree() {
+ ReadOnlyDataTree getDataTree() {
return tree;
}
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedTransactions;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
/**
* {@link LocalTransactionFactory} for instantiating backing transactions which are
implements LocalTransactionFactory {
private final ActorSelection leader;
- private final DataTree dataTree;
+ private final ReadOnlyDataTree dataTree;
private final ActorUtils actorUtils;
- LocalTransactionFactoryImpl(final ActorUtils actorUtils, final ActorSelection leader, final DataTree dataTree) {
+ LocalTransactionFactoryImpl(final ActorUtils actorUtils, final ActorSelection leader,
+ final ReadOnlyDataTree dataTree) {
this.leader = requireNonNull(leader);
this.dataTree = requireNonNull(dataTree);
this.actorUtils = actorUtils;
}
- DataTree getDataTree() {
+ ReadOnlyDataTree getDataTree() {
return dataTree;
}
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.concurrent.Future;
@Override
protected LocalTransactionChain factoryForShard(final String shardName, final ActorSelection shardLeader,
- final DataTree dataTree) {
+ final ReadOnlyDataTree dataTree) {
final LocalTransactionChain ret = new LocalTransactionChain(this, shardLeader, dataTree);
LOG.debug("Allocated transaction chain {} for shard {} leader {}", ret, shardName, shardLeader);
return ret;
import org.opendaylight.controller.cluster.datastore.messages.PrimaryShardInfo;
import org.opendaylight.controller.cluster.datastore.utils.ActorUtils;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
import scala.concurrent.Future;
/**
@Override
protected LocalTransactionFactoryImpl factoryForShard(final String shardName, final ActorSelection shardLeader,
- final DataTree dataTree) {
+ final ReadOnlyDataTree dataTree) {
return new LocalTransactionFactoryImpl(getActorUtils(), shardLeader, dataTree);
}
import org.apache.commons.lang3.ObjectUtils;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
/**
* Local message sent in reply to FindPrimaryShard to indicate the primary shard is local to the caller.
public class LocalPrimaryShardFound {
private final String primaryPath;
- private final DataTree localShardDataTree;
+ private final ReadOnlyDataTree localShardDataTree;
- public LocalPrimaryShardFound(@NonNull String primaryPath, @NonNull DataTree localShardDataTree) {
+ public LocalPrimaryShardFound(@NonNull String primaryPath, @NonNull ReadOnlyDataTree localShardDataTree) {
this.primaryPath = requireNonNull(primaryPath);
this.localShardDataTree = requireNonNull(localShardDataTree);
}
return primaryPath;
}
- public @NonNull DataTree getLocalShardDataTree() {
+ public @NonNull ReadOnlyDataTree getLocalShardDataTree() {
return localShardDataTree;
}
import akka.actor.ActorSelection;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
/**
* Local message DTO that contains information about the primary shard.
public class PrimaryShardInfo {
private final ActorSelection primaryShardActor;
private final short primaryShardVersion;
- private final DataTree localShardDataTree;
+ private final ReadOnlyDataTree localShardDataTree;
public PrimaryShardInfo(@NonNull ActorSelection primaryShardActor, short primaryShardVersion,
- @NonNull DataTree localShardDataTree) {
+ @NonNull ReadOnlyDataTree localShardDataTree) {
this.primaryShardActor = requireNonNull(primaryShardActor);
this.primaryShardVersion = primaryShardVersion;
this.localShardDataTree = requireNonNull(localShardDataTree);
* Returns an Optional whose value contains the primary shard's DataTree if the primary shard is local
* to the caller. Otherwise the Optional value is absent.
*/
- public @NonNull Optional<DataTree> getLocalShardDataTree() {
+ public @NonNull Optional<ReadOnlyDataTree> getLocalShardDataTree() {
return Optional.ofNullable(localShardDataTree);
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.cluster.notifications.LeaderStateChanged;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
/**
* A local message derived from LeaderStateChanged containing additional Shard-specific info that is sent
* @author Thomas Pantelis
*/
public class ShardLeaderStateChanged extends LeaderStateChanged {
-
- private final DataTree localShardDataTree;
+ private final ReadOnlyDataTree localShardDataTree;
public ShardLeaderStateChanged(@NonNull String memberId, @Nullable String leaderId,
- @NonNull DataTree localShardDataTree, short leaderPayloadVersion) {
+ @NonNull ReadOnlyDataTree localShardDataTree, short leaderPayloadVersion) {
super(memberId, leaderId, leaderPayloadVersion);
this.localShardDataTree = requireNonNull(localShardDataTree);
}
this.localShardDataTree = null;
}
- public @NonNull Optional<DataTree> getLocalShardDataTree() {
+ public @NonNull Optional<ReadOnlyDataTree> getLocalShardDataTree() {
return Optional.ofNullable(localShardDataTree);
}
}
import org.opendaylight.controller.cluster.datastore.shardmanager.ShardManager.OnShardInitialized;
import org.opendaylight.controller.cluster.datastore.shardmanager.ShardManager.OnShardReady;
import org.opendaylight.controller.cluster.raft.RaftState;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final AtomicShardContextProvider schemaContextProvider = new AtomicShardContextProvider();
private ActorRef actor;
- private Optional<DataTree> localShardDataTree;
+ private Optional<ReadOnlyDataTree> localShardDataTree;
private boolean leaderAvailable = false;
// flag that determines if the actor is ready for business
return shardId;
}
- void setLocalDataTree(final Optional<DataTree> dataTree) {
+ void setLocalDataTree(final Optional<ReadOnlyDataTree> dataTree) {
this.localShardDataTree = dataTree;
}
- Optional<DataTree> getLocalShardDataTree() {
+ Optional<ReadOnlyDataTree> getLocalShardDataTree() {
return localShardDataTree;
}
import org.opendaylight.controller.cluster.raft.client.messages.Shutdown;
import org.opendaylight.controller.cluster.reporting.MetricsReporter;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ReadOnlyDataTree;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
private PrimaryShardInfo onPrimaryShardFound(final String shardName, final String primaryActorPath,
- final short primaryVersion, final DataTree localShardDataTree) {
+ final short primaryVersion, final ReadOnlyDataTree localShardDataTree) {
ActorSelection actorSelection = actorSystem.actorSelection(primaryActorPath);
PrimaryShardInfo info = localShardDataTree == null ? new PrimaryShardInfo(actorSelection, primaryVersion) :
new PrimaryShardInfo(actorSelection, primaryVersion, localShardDataTree);