import com.google.common.collect.Sets;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.Uninterruptibles;
+import java.lang.reflect.Constructor;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
import org.mockito.Mockito;
import org.opendaylight.controller.cluster.datastore.DatastoreContext.Builder;
import org.opendaylight.controller.cluster.datastore.config.Configuration;
import org.opendaylight.controller.cluster.datastore.config.ConfigurationImpl;
import org.opendaylight.controller.cluster.datastore.config.EmptyModuleShardConfigProvider;
import org.opendaylight.controller.cluster.datastore.jmx.mbeans.shard.ShardStats;
+import org.opendaylight.controller.cluster.datastore.messages.OnDemandShardState;
import org.opendaylight.controller.cluster.datastore.persisted.DatastoreSnapshot;
import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
+import org.opendaylight.controller.cluster.raft.client.messages.GetOnDemandRaftState;
import org.opendaylight.controller.md.cluster.datastore.model.SchemaContextHelper;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
+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.yangtools.yang.model.api.SchemaContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
import scala.concurrent.Future;
import scala.concurrent.duration.Duration;
public class IntegrationTestKit extends ShardTestKit {
+ private static final Logger LOG = LoggerFactory.getLogger(IntegrationTestKit.class);
+
protected DatastoreContext.Builder datastoreContextBuilder;
protected DatastoreSnapshot restoreFromSnapshot;
+ private final int commitTimeout;
public IntegrationTestKit(final ActorSystem actorSystem, final Builder datastoreContextBuilder) {
+ this(actorSystem, datastoreContextBuilder, 7);
+ }
+
+ public IntegrationTestKit(final ActorSystem actorSystem, final Builder datastoreContextBuilder,
+ final int commitTimeout) {
super(actorSystem);
this.datastoreContextBuilder = datastoreContextBuilder;
+ this.commitTimeout = commitTimeout;
}
public DatastoreContext.Builder getDatastoreContextBuilder() {
return datastoreContextBuilder;
}
- public AbstractDataStore setupDistributedDataStore(final String typeName, final String... shardNames) {
- return setupDistributedDataStore(typeName, "module-shards.conf", true, SchemaContextHelper.full(), shardNames);
+ public DistributedDataStore setupDistributedDataStore(final String typeName, final String moduleShardsConfig,
+ final boolean waitUntilLeader,
+ final SchemaContext schemaContext) throws Exception {
+ return setupDistributedDataStore(typeName, moduleShardsConfig, "modules.conf", waitUntilLeader, schemaContext);
+ }
+
+ public DistributedDataStore setupDistributedDataStore(final String typeName, final String moduleShardsConfig,
+ final String modulesConfig,
+ final boolean waitUntilLeader,
+ final SchemaContext schemaContext,
+ final String... shardNames) throws Exception {
+ return (DistributedDataStore) setupAbstractDataStore(DistributedDataStore.class, typeName, moduleShardsConfig,
+ modulesConfig, waitUntilLeader, schemaContext, shardNames);
}
- public AbstractDataStore setupDistributedDataStore(final String typeName, final boolean waitUntilLeader,
- final String... shardNames) {
- return setupDistributedDataStore(typeName, "module-shards.conf", waitUntilLeader,
+ public AbstractDataStore setupAbstractDataStore(final Class<? extends AbstractDataStore> implementation,
+ final String typeName, final String... shardNames)
+ throws Exception {
+ return setupAbstractDataStore(implementation, typeName, "module-shards.conf", true,
SchemaContextHelper.full(), shardNames);
}
- public AbstractDataStore setupDistributedDataStore(final String typeName, final String moduleShardsConfig,
- final boolean waitUntilLeader, final String... shardNames) {
- return setupDistributedDataStore(typeName, moduleShardsConfig, waitUntilLeader,
+ public AbstractDataStore setupAbstractDataStore(final Class<? extends AbstractDataStore> implementation,
+ final String typeName, final boolean waitUntilLeader,
+ final String... shardNames) throws Exception {
+ return setupAbstractDataStore(implementation, typeName, "module-shards.conf", waitUntilLeader,
SchemaContextHelper.full(), shardNames);
}
- public AbstractDataStore setupDistributedDataStore(final String typeName, final String moduleShardsConfig,
- final boolean waitUntilLeader, final SchemaContext schemaContext, final String... shardNames) {
+ public AbstractDataStore setupAbstractDataStore(final Class<? extends AbstractDataStore> implementation,
+ final String typeName, final String moduleShardsConfig,
+ final boolean waitUntilLeader, final String... shardNames)
+ throws Exception {
+ return setupAbstractDataStore(implementation, typeName, moduleShardsConfig, waitUntilLeader,
+ SchemaContextHelper.full(), shardNames);
+ }
+
+ public AbstractDataStore setupAbstractDataStore(final Class<? extends AbstractDataStore> implementation,
+ final String typeName, final String moduleShardsConfig,
+ final boolean waitUntilLeader,
+ final SchemaContext schemaContext,
+ final String... shardNames) throws Exception {
+ return setupAbstractDataStore(implementation, typeName, moduleShardsConfig, "modules.conf", waitUntilLeader,
+ schemaContext, shardNames);
+ }
+
+ private AbstractDataStore setupAbstractDataStore(final Class<? extends AbstractDataStore> implementation,
+ final String typeName, final String moduleShardsConfig,
+ final String modulesConfig, final boolean waitUntilLeader,
+ final SchemaContext schemaContext, final String... shardNames)
+ throws Exception {
final ClusterWrapper cluster = new ClusterWrapperImpl(getSystem());
- final Configuration config = new ConfigurationImpl(moduleShardsConfig, "modules.conf");
+ final Configuration config = new ConfigurationImpl(moduleShardsConfig, modulesConfig);
- datastoreContextBuilder.dataStoreName(typeName);
+ setDataStoreName(typeName);
- DatastoreContext datastoreContext = datastoreContextBuilder.build();
- DatastoreContextFactory mockContextFactory = Mockito.mock(DatastoreContextFactory.class);
+ final DatastoreContext datastoreContext = datastoreContextBuilder.build();
+ final DatastoreContextFactory mockContextFactory = Mockito.mock(DatastoreContextFactory.class);
Mockito.doReturn(datastoreContext).when(mockContextFactory).getBaseDatastoreContext();
Mockito.doReturn(datastoreContext).when(mockContextFactory).getShardDatastoreContext(Mockito.anyString());
- AbstractDataStore dataStore = new DistributedDataStore(getSystem(), cluster, config, mockContextFactory,
- restoreFromSnapshot);
+ final Constructor<? extends AbstractDataStore> constructor = implementation.getDeclaredConstructor(
+ ActorSystem.class, ClusterWrapper.class, Configuration.class,
+ DatastoreContextFactory.class, DatastoreSnapshot.class);
+
+ final AbstractDataStore dataStore = constructor.newInstance(getSystem(), cluster, config, mockContextFactory,
+ restoreFromSnapshot);
dataStore.onGlobalContextUpdated(schemaContext);
return dataStore;
}
+ private void setDataStoreName(final String typeName) {
+ if ("config".equals(typeName)) {
+ datastoreContextBuilder.logicalStoreType(LogicalDatastoreType.CONFIGURATION);
+ } else if ("operational".equals(typeName)) {
+ datastoreContextBuilder.logicalStoreType(LogicalDatastoreType.OPERATIONAL);
+ } else {
+ datastoreContextBuilder.dataStoreName(typeName);
+ }
+ }
+
public DistributedDataStore setupDistributedDataStoreWithoutConfig(final String typeName,
final SchemaContext schemaContext) {
final ClusterWrapper cluster = new ClusterWrapperImpl(getSystem());
final ConfigurationImpl configuration = new ConfigurationImpl(new EmptyModuleShardConfigProvider());
- getDatastoreContextBuilder().dataStoreName(typeName);
+ setDataStoreName(typeName);
final DatastoreContext datastoreContext = getDatastoreContextBuilder().build();
return dataStore;
}
+ public DistributedDataStore setupDistributedDataStoreWithoutConfig(final String typeName,
+ final SchemaContext schemaContext,
+ final LogicalDatastoreType storeType) {
+ final ClusterWrapper cluster = new ClusterWrapperImpl(getSystem());
+ final ConfigurationImpl configuration = new ConfigurationImpl(new EmptyModuleShardConfigProvider());
+
+ setDataStoreName(typeName);
+
+ final DatastoreContext datastoreContext =
+ getDatastoreContextBuilder().logicalStoreType(storeType).build();
+
+ final DatastoreContextFactory mockContextFactory = Mockito.mock(DatastoreContextFactory.class);
+ Mockito.doReturn(datastoreContext).when(mockContextFactory).getBaseDatastoreContext();
+ Mockito.doReturn(datastoreContext).when(mockContextFactory).getShardDatastoreContext(Mockito.anyString());
+
+ final DistributedDataStore dataStore = new DistributedDataStore(getSystem(), cluster,
+ configuration, mockContextFactory, restoreFromSnapshot);
+
+ dataStore.onGlobalContextUpdated(schemaContext);
+
+ datastoreContextBuilder = DatastoreContext.newBuilderFrom(datastoreContext);
+ return dataStore;
+ }
+
public void waitUntilLeader(final ActorContext actorContext, final String... shardNames) {
for (String shardName: shardNames) {
ActorRef shard = findLocalShard(actorContext, shardName);
return shard;
}
+ public static void waitUntilShardIsDown(final ActorContext actorContext, final String shardName) {
+ for (int i = 0; i < 20 * 5 ; i++) {
+ LOG.debug("Waiting for shard down {}", shardName);
+ Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
+ Optional<ActorRef> shardReply = actorContext.findLocalShard(shardName);
+ if (!shardReply.isPresent()) {
+ return;
+ }
+ }
+
+ throw new IllegalStateException("Shard[" + shardName + " did not shutdown in time");
+ }
+
public static void verifyShardStats(final AbstractDataStore datastore, final String shardName,
final ShardStatsVerifier verifier) throws Exception {
ActorContext actorContext = datastore.getActorContext();
throw lastError;
}
+ public static void verifyShardState(final AbstractDataStore datastore, final String shardName,
+ final Consumer<OnDemandShardState> verifier) throws Exception {
+ ActorContext actorContext = datastore.getActorContext();
+
+ Future<ActorRef> future = actorContext.findLocalShardAsync(shardName);
+ ActorRef shardActor = Await.result(future, Duration.create(10, TimeUnit.SECONDS));
+
+ AssertionError lastError = null;
+ Stopwatch sw = Stopwatch.createStarted();
+ while (sw.elapsed(TimeUnit.SECONDS) <= 5) {
+ OnDemandShardState shardState = (OnDemandShardState)actorContext
+ .executeOperation(shardActor, GetOnDemandRaftState.INSTANCE);
+
+ try {
+ verifier.accept(shardState);
+ return;
+ } catch (AssertionError e) {
+ lastError = e;
+ Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
+ }
+ }
+
+ throw lastError;
+ }
+
void testWriteTransaction(final AbstractDataStore dataStore, final YangInstanceIdentifier nodePath,
final NormalizedNode<?, ?> nodeToWrite) throws Exception {
}
public void doCommit(final DOMStoreThreePhaseCommitCohort cohort) throws Exception {
- Boolean canCommit = cohort.canCommit().get(7, TimeUnit.SECONDS);
+ Boolean canCommit = cohort.canCommit().get(commitTimeout, TimeUnit.SECONDS);
assertEquals("canCommit", true, canCommit);
cohort.preCommit().get(5, TimeUnit.SECONDS);
cohort.commit().get(5, TimeUnit.SECONDS);
void doCommit(final ListenableFuture<Boolean> canCommitFuture, final DOMStoreThreePhaseCommitCohort cohort)
throws Exception {
- Boolean canCommit = canCommitFuture.get(7, TimeUnit.SECONDS);
+ Boolean canCommit = canCommitFuture.get(commitTimeout, TimeUnit.SECONDS);
assertEquals("canCommit", true, canCommit);
cohort.preCommit().get(5, TimeUnit.SECONDS);
cohort.commit().get(5, TimeUnit.SECONDS);