import org.opendaylight.controller.cluster.access.concepts.FrontendIdentifier;
import org.opendaylight.controller.cluster.access.concepts.FrontendType;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
public class ActorBehaviorTest {
private static final String MEMBER_1_FRONTEND_TYPE_1 = "member-1-frontend-type-1";
- private static final FiniteDuration TIMEOUT = Duration.apply(5, TimeUnit.SECONDS);
+ private static final FiniteDuration TIMEOUT = FiniteDuration.create(5, TimeUnit.SECONDS);
private ActorSystem system;
private TestProbe probe;
import org.opendaylight.controller.cluster.access.concepts.FrontendIdentifier;
import org.opendaylight.controller.cluster.access.concepts.FrontendType;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
public class ClientActorContextTest {
@Test
public void testExecuteInActorScheduled() {
- final FiniteDuration delay = Duration.apply(1, TimeUnit.SECONDS);
- ctx.executeInActor(command, delay);
+ ctx.executeInActor(command, FiniteDuration.create(1, TimeUnit.SECONDS));
probe.expectMsg(command);
}
import org.opendaylight.controller.cluster.raft.persisted.EmptyState;
import org.opendaylight.controller.cluster.raft.persisted.Snapshot;
import org.slf4j.Logger;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* Handles snapshot related messages for a RaftActor.
private final RaftActorSnapshotCohort cohort;
private final Logger log;
- private Duration snapshotReplyActorTimeout = Duration.create(30, TimeUnit.SECONDS);
+ private FiniteDuration snapshotReplyActorTimeout = FiniteDuration.create(30, TimeUnit.SECONDS);
RaftActorSnapshotMessageSupport(final RaftActorContext context, final RaftActorSnapshotCohort cohort) {
this.context = context;
}
@VisibleForTesting
- void setSnapshotReplyActorTimeout(Duration snapshotReplyActorTimeout) {
+ void setSnapshotReplyActorTimeout(FiniteDuration snapshotReplyActorTimeout) {
this.snapshotReplyActorTimeout = snapshotReplyActorTimeout;
}
}
* 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.raft;
import static org.junit.Assert.assertEquals;
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
public class RaftActorTestKit extends TestKit {
@SuppressWarnings("checkstyle:IllegalCatch")
public static void waitUntilLeader(final ActorRef actorRef) {
- FiniteDuration duration = Duration.create(100, TimeUnit.MILLISECONDS);
+ FiniteDuration duration = FiniteDuration.create(100, TimeUnit.MILLISECONDS);
for (int i = 0; i < 20 * 5; i++) {
Future<Object> future = Patterns.ask(actorRef, FindLeader.INSTANCE, new Timeout(duration));
try {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
/**
RaftState actualState;
try {
actualState = (RaftState) Await.result(Patterns.ask(actor.self(), GetBehaviorState.INSTANCE,
- Timeout.apply(5, TimeUnit.SECONDS)), Duration.apply(5, TimeUnit.SECONDS));
+ Timeout.apply(5, TimeUnit.SECONDS)), FiniteDuration.create(5, TimeUnit.SECONDS));
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
* 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.raft.utils;
import akka.actor.ActorRef;
import org.junit.Assert;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
public class MessageCollectorActor extends UntypedAbstractActor {
@SuppressWarnings({"unchecked", "checkstyle:illegalCatch"})
public static List<Object> getAllMessages(final ActorRef actor) {
- FiniteDuration operationDuration = Duration.create(5, TimeUnit.SECONDS);
+ FiniteDuration operationDuration = FiniteDuration.create(5, TimeUnit.SECONDS);
Timeout operationTimeout = new Timeout(operationDuration);
Future<Object> future = Patterns.ask(actor, GET_ALL_MESSAGES, operationTimeout);
public static void waitUntilReady(final ActorRef actor) throws TimeoutException, InterruptedException {
long timeout = 500;
- FiniteDuration duration = Duration.create(timeout, TimeUnit.MILLISECONDS);
+ FiniteDuration duration = FiniteDuration.create(timeout, TimeUnit.MILLISECONDS);
for (int i = 0; i < 10; i++) {
try {
Await.ready(Patterns.ask(actor, ARE_YOU_READY, timeout), duration);
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
public class RemoteYangTextSourceProviderImplTest {
remoteRepository.getYangTextSchemaSource(ID);
assertTrue(retrievedSourceFuture.isCompleted());
YangTextSchemaSource resultSchemaSource = Await.result(retrievedSourceFuture,
- Duration.Zero()).getRepresentation();
+ FiniteDuration.Zero()).getRepresentation();
assertEquals(resultSchemaSource.getIdentifier(), schemaSource.getIdentifier());
assertArrayEquals(resultSchemaSource.read(), schemaSource.read());
}
Future<YangTextSchemaSourceSerializationProxy> retrievedSourceFuture =
remoteRepository.getYangTextSchemaSource(ID);
assertTrue(retrievedSourceFuture.isCompleted());
- Await.result(retrievedSourceFuture, Duration.Zero());
+ Await.result(retrievedSourceFuture, FiniteDuration.Zero());
}
@Test
public void testGetProvidedSources() throws Exception {
Set<SourceIdentifier> remoteProvidedSources = Await.result(remoteRepository
- .getProvidedSources(), Duration.Zero());
+ .getProvidedSources(), FiniteDuration.Zero());
assertEquals(providedSources, remoteProvidedSources);
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
public class ActorSystemProviderImpl implements ActorSystemProvider, AutoCloseable {
private static final String ACTOR_SYSTEM_NAME = "opendaylight-cluster-data";
LOG.info("Shutting down ActorSystem");
try {
- Await.result(actorSystem.terminate(), Duration.create(10, TimeUnit.SECONDS));
+ Await.result(actorSystem.terminate(), FiniteDuration.create(10, TimeUnit.SECONDS));
} catch (final Exception e) {
LOG.warn("Error awaiting actor termination", e);
}
public class DatastoreContext implements ClientActorConfig {
public static final String METRICS_DOMAIN = "org.opendaylight.controller.cluster.datastore";
- public static final Duration DEFAULT_SHARD_TRANSACTION_IDLE_TIMEOUT = Duration.create(10, TimeUnit.MINUTES);
+ public static final FiniteDuration DEFAULT_SHARD_TRANSACTION_IDLE_TIMEOUT = FiniteDuration.create(10,
+ TimeUnit.MINUTES);
public static final int DEFAULT_OPERATION_TIMEOUT_IN_MS = 5000;
public static final int DEFAULT_SHARD_TX_COMMIT_TIMEOUT_IN_SECONDS = 30;
public static final int DEFAULT_JOURNAL_RECOVERY_BATCH_SIZE = 1;
private final DefaultConfigParamsImpl raftConfig = new DefaultConfigParamsImpl();
private InMemoryDOMDataStoreConfigProperties dataStoreProperties;
- private Duration shardTransactionIdleTimeout = DatastoreContext.DEFAULT_SHARD_TRANSACTION_IDLE_TIMEOUT;
+ private FiniteDuration shardTransactionIdleTimeout = DatastoreContext.DEFAULT_SHARD_TRANSACTION_IDLE_TIMEOUT;
private long operationTimeoutInMillis = DEFAULT_OPERATION_TIMEOUT_IN_MS;
private String dataStoreMXBeanType;
private int shardTransactionCommitTimeoutInSeconds = DEFAULT_SHARD_TX_COMMIT_TIMEOUT_IN_SECONDS;
public Builder shardTransactionIdleTimeout(final long timeout, final TimeUnit unit) {
- datastoreContext.shardTransactionIdleTimeout = Duration.create(timeout, unit);
+ datastoreContext.shardTransactionIdleTimeout = FiniteDuration.create(timeout, unit);
return this;
}
* 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.datastore;
import akka.actor.ActorRef;
import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
/**
if (txCommitTimeoutCheckSchedule == null) {
// Schedule a message to be periodically sent to check if the current in-progress
// transaction should be expired and aborted.
- FiniteDuration period = Duration.create(transactionCommitTimeout / 3, TimeUnit.MILLISECONDS);
+ FiniteDuration period = FiniteDuration.create(transactionCommitTimeout / 3, TimeUnit.MILLISECONDS);
txCommitTimeoutCheckSchedule = getContext().system().scheduler().schedule(
period, period, getSelf(),
TX_COMMIT_TIMEOUT_CHECK_MESSAGE, getContext().dispatcher(), ActorRef.noSender());
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* Internal shard state, similar to a DOMStore, but optimized for use in the actor system,
}
}
- private static final Timeout COMMIT_STEP_TIMEOUT = new Timeout(Duration.create(5, TimeUnit.SECONDS));
+ private static final Timeout COMMIT_STEP_TIMEOUT = new Timeout(FiniteDuration.create(5, TimeUnit.SECONDS));
private static final Logger LOG = LoggerFactory.getLogger(ShardDataTree.class);
/**
import org.opendaylight.controller.cluster.datastore.messages.CloseDataTreeNotificationListenerRegistration;
import org.opendaylight.controller.cluster.datastore.messages.CloseDataTreeNotificationListenerRegistrationReply;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* Actor co-located with a shard. It exists only to terminate the registration when
registration = null;
if (killSchedule == null) {
- killSchedule = getContext().system().scheduler().scheduleOnce(Duration.create(killDelay,
+ killSchedule = getContext().system().scheduler().scheduleOnce(FiniteDuration.create(killDelay,
TimeUnit.MILLISECONDS), getSelf(), PoisonPill.getInstance(), getContext().dispatcher(),
ActorRef.noSender());
}
import org.slf4j.LoggerFactory;
import scala.concurrent.ExecutionContext;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
/**
@Override
public SupervisorStrategy supervisorStrategy() {
- return new OneForOneStrategy(10, Duration.create("1 minute"),
+ return new OneForOneStrategy(10, FiniteDuration.create(1, TimeUnit.MINUTES),
(Function<Throwable, Directive>) t -> {
LOG.warn("Supervisor Strategy caught unexpected exception - resuming", t);
return SupervisorStrategy.resume();
* 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.datastore.utils;
import static akka.pattern.Patterns.ask;
import scala.concurrent.Await;
import scala.concurrent.ExecutionContext;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
/**
private void setCachedProperties() {
txRateLimiter = new TransactionRateLimiter(this);
- operationDuration = Duration.create(datastoreContext.getOperationTimeoutInMillis(), TimeUnit.MILLISECONDS);
+ operationDuration = FiniteDuration.create(datastoreContext.getOperationTimeoutInMillis(),
+ TimeUnit.MILLISECONDS);
operationTimeout = new Timeout(operationDuration);
- transactionCommitOperationTimeout = new Timeout(Duration.create(
+ transactionCommitOperationTimeout = new Timeout(FiniteDuration.create(
datastoreContext.getShardTransactionCommitTimeoutInSeconds(), TimeUnit.SECONDS));
shardInitializationTimeout = new Timeout(datastoreContext.getShardInitializationTimeout().duration().$times(2));
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* Abstract base for shard unit tests.
Future<Object> future = Patterns.ask(shard, newBatchedModifications(nextTransactionId(),
id, node, true, true, 1), new Timeout(5, TimeUnit.SECONDS));
try {
- Await.ready(future, Duration.create(5, TimeUnit.SECONDS));
+ Await.ready(future, FiniteDuration.create(5, TimeUnit.SECONDS));
} catch (TimeoutException e) {
throw new ExecutionException(e);
}
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* Abstract base class for TransactionProxy unit tests.
for (Future<?> future : proxy.getCohortFutures()) {
assertNotNull("Ready operation Future is null", future);
try {
- futureResults.add(Await.result(future, Duration.create(5, TimeUnit.SECONDS)));
+ futureResults.add(Await.result(future, FiniteDuration.create(5, TimeUnit.SECONDS)));
} catch (Exception e) {
futureResults.add(e);
}
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
public class IntegrationTestKit extends ShardTestKit {
ActorContext actorContext = datastore.getActorContext();
Future<ActorRef> future = actorContext.findLocalShardAsync(shardName);
- ActorRef shardActor = Await.result(future, Duration.create(10, TimeUnit.SECONDS));
+ ActorRef shardActor = Await.result(future, FiniteDuration.create(10, TimeUnit.SECONDS));
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
ActorContext actorContext = datastore.getActorContext();
Future<ActorRef> future = actorContext.findLocalShardAsync(shardName);
- ActorRef shardActor = Await.result(future, Duration.create(10, TimeUnit.SECONDS));
+ ActorRef shardActor = Await.result(future, FiniteDuration.create(10, TimeUnit.SECONDS));
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* Class that represents a cluster member node for unit tests. It encapsulates an actor system with
ActorContext actorContext = datastore.getActorContext();
Future<ActorRef> future = actorContext.findLocalShardAsync(shardName);
- ActorRef shardActor = Await.result(future, Duration.create(10, TimeUnit.SECONDS));
+ ActorRef shardActor = Await.result(future, FiniteDuration.create(10, TimeUnit.SECONDS));
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
public class ShardTestKit extends TestKit {
@SuppressWarnings("checkstyle:IllegalCatch")
public static String waitUntilLeader(final ActorRef shard) {
- FiniteDuration duration = Duration.create(100, TimeUnit.MILLISECONDS);
+ FiniteDuration duration = FiniteDuration.create(100, TimeUnit.MILLISECONDS);
for (int i = 0; i < 20 * 5; i++) {
Future<Object> future = Patterns.ask(shard, FindLeader.INSTANCE, new Timeout(duration));
try {
@SuppressWarnings("checkstyle:IllegalCatch")
public void waitUntilNoLeader(final ActorRef shard) {
- FiniteDuration duration = Duration.create(100, TimeUnit.MILLISECONDS);
+ FiniteDuration duration = FiniteDuration.create(100, TimeUnit.MILLISECONDS);
Object lastResponse = null;
for (int i = 0; i < 20 * 5; i++) {
Future<Object> future = Patterns.ask(shard, FindLeader.INSTANCE, new Timeout(duration));
* 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.datastore;
import akka.actor.ActorRef;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* Covers negative test cases.
Future<Object> future = akka.pattern.Patterns.ask(subject,
new ReadData(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION), 3000);
- Await.result(future, Duration.create(3, TimeUnit.SECONDS));
+ Await.result(future, FiniteDuration.create(3, TimeUnit.SECONDS));
subject.underlyingActor().getDOMStoreTransaction().abortFromTransactionActor();
future = akka.pattern.Patterns.ask(subject, new ReadData(YangInstanceIdentifier.EMPTY,
DataStoreVersions.CURRENT_VERSION), 3000);
- Await.result(future, Duration.create(3, TimeUnit.SECONDS));
+ Await.result(future, FiniteDuration.create(3, TimeUnit.SECONDS));
}
Future<Object> future = akka.pattern.Patterns.ask(subject,
new ReadData(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION), 3000);
- Await.result(future, Duration.create(3, TimeUnit.SECONDS));
+ Await.result(future, FiniteDuration.create(3, TimeUnit.SECONDS));
subject.underlyingActor().getDOMStoreTransaction().abortFromTransactionActor();
future = akka.pattern.Patterns.ask(subject, new ReadData(YangInstanceIdentifier.EMPTY,
DataStoreVersions.CURRENT_VERSION), 3000);
- Await.result(future, Duration.create(3, TimeUnit.SECONDS));
+ Await.result(future, FiniteDuration.create(3, TimeUnit.SECONDS));
}
@Test(expected = ReadFailedException.class)
Future<Object> future = akka.pattern.Patterns.ask(subject,
new DataExists(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION), 3000);
- Await.result(future, Duration.create(3, TimeUnit.SECONDS));
+ Await.result(future, FiniteDuration.create(3, TimeUnit.SECONDS));
subject.underlyingActor().getDOMStoreTransaction().abortFromTransactionActor();
future = akka.pattern.Patterns.ask(subject,
new DataExists(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION), 3000);
- Await.result(future, Duration.create(3, TimeUnit.SECONDS));
+ Await.result(future, FiniteDuration.create(3, TimeUnit.SECONDS));
}
}
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
/**
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
while (sw.elapsed(TimeUnit.SECONDS) <= 5) {
- FiniteDuration operationDuration = Duration.create(5, TimeUnit.SECONDS);
+ FiniteDuration operationDuration = FiniteDuration.create(5, TimeUnit.SECONDS);
Future<Object> future = Patterns.ask(shard, GetOnDemandRaftState.INSTANCE, new Timeout(operationDuration));
OnDemandRaftState raftState = (OnDemandRaftState)Await.result(future, operationDuration);
try {
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* Unit tests for DistributedEntityOwnershipService.
Future<ActorRef> future = dataStore.getActorContext().findLocalShardAsync(
DistributedEntityOwnershipService.ENTITY_OWNERSHIP_SHARD_NAME);
- ActorRef shardActor = Await.result(future, Duration.create(10, TimeUnit.SECONDS));
+ ActorRef shardActor = Await.result(future, FiniteDuration.create(10, TimeUnit.SECONDS));
assertNotNull(DistributedEntityOwnershipService.ENTITY_OWNERSHIP_SHARD_NAME + " not found", shardActor);
service.close();
import akka.actor.Props;
import akka.actor.SupervisorStrategy;
import com.google.common.base.Preconditions;
+import java.util.concurrent.TimeUnit;
import org.opendaylight.controller.cluster.common.actor.AbstractUntypedActor;
import org.opendaylight.controller.remote.rpc.registry.RpcRegistry;
import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* This class acts as a supervisor, creates all the actors, resumes them, if an exception is thrown. It also registers
@Override
public SupervisorStrategy supervisorStrategy() {
- return new OneForOneStrategy(10, Duration.create("1 minute"), t -> {
+ return new OneForOneStrategy(10, FiniteDuration.create(1, TimeUnit.MINUTES), t -> {
LOG.error("An exception happened actor will be resumed", t);
return SupervisorStrategy.resume();
});
* 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.remote.rpc;
import static org.mockito.Mockito.mock;
import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import scala.concurrent.Await;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
public class RemoteRpcProviderTest {
static ActorSystem system;
final ActorRef actorRef = Await.result(
system.actorSelection(moduleConfig.getRpcManagerPath()).resolveOne(
- Duration.create(1, TimeUnit.SECONDS)), Duration.create(2, TimeUnit.SECONDS));
+ FiniteDuration.create(1, TimeUnit.SECONDS)), FiniteDuration.create(2, TimeUnit.SECONDS));
Assert.assertTrue(actorRef.path().toString().contains(moduleConfig.getRpcManagerPath()));
}
Code Review / controller.git / commitdiff