import static java.util.Objects.requireNonNull;
-import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
import io.netty.util.Timer;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
private final Timer timer;
private final RpcProviderService rpcProviderRegistry;
private final ClusterSingletonServiceProvider cssp;
- private final ListeningExecutorService exec = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
+ private final ExecutorService exec = Executors.newSingleThreadExecutor();
@Inject
@Activate
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import io.netty.util.Timeout;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.opendaylight.bgpcep.programming.NanotimeUtil;
private final Map<InstructionId, InstructionImpl> insns = new HashMap<>();
private final InstanceIdentifier<InstructionsQueue> qid;
private final NotificationPublishService notifs;
- private final ListeningExecutorService executor;
+ private final Executor executor;
private final DataBroker dataProvider;
private final Timer timer;
private final String instructionId;
}
ProgrammingServiceImpl(final DataBroker dataProvider, final NotificationPublishService notifs,
- final ListeningExecutorService executor, final RpcProviderService rpcProviderRegistry,
+ final Executor executor, final RpcProviderService rpcProviderRegistry,
final ClusterSingletonServiceProvider cssp, final Timer timer, final String instructionId) {
this.dataProvider = requireNonNull(dataProvider);
this.instructionId = requireNonNull(instructionId);
@Override
public ListenableFuture<RpcResult<CancelInstructionOutput>> cancelInstruction(final CancelInstructionInput input) {
- return executor.submit(() -> realCancelInstruction(input));
+ return Futures.submit(() -> realCancelInstruction(input), executor);
}
@Override
public ListenableFuture<RpcResult<CleanInstructionsOutput>> cleanInstructions(final CleanInstructionsInput input) {
- return executor.submit(() -> realCleanInstructions(input));
+ return Futures.submit(() -> realCleanInstructions(input), executor);
}
private synchronized RpcResult<CancelInstructionOutput> realCancelInstruction(final CancelInstructionInput input) {
* This task should be ingress-weighed, so we reinsert it into the
* same execution service.
*/
- executor.submit(() -> tryScheduleInstruction(instruction));
+ executor.execute(() -> tryScheduleInstruction(instruction));
return ret;
}
package org.opendaylight.bgpcep.programming.impl;
import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.Callable;
-import org.mockito.stubbing.Answer;
+import java.util.concurrent.Executor;
final class MockedExecutorWrapper {
-
- private final List<Object> submittedTasksToExecutor;
+ private final List<Runnable> submittedTasksToExecutor;
MockedExecutorWrapper() {
- this.submittedTasksToExecutor = new ArrayList<>();
+ submittedTasksToExecutor = new ArrayList<>();
}
- ListeningExecutorService getMockedExecutor() {
- final ListeningExecutorService mockedExecutor = mock(ListeningExecutorService.class);
- final Answer<ListenableFuture<?>> submitAnswer = invocation -> {
- final Object task = invocation.getArguments()[0];
- this.submittedTasksToExecutor.add(task);
-
- Object result = null;
- if (task instanceof Runnable) {
- ((Runnable) task).run();
- } else if (task instanceof Callable) {
- result = ((Callable<?>) task).call();
- }
-
- final ListenableFuture<?> mockedFuture = mock(ListenableFuture.class);
- doReturn(result).when(mockedFuture).get();
- return mockedFuture;
+ Executor getMockedExecutor() {
+ return runnable -> {
+ submittedTasksToExecutor.add(runnable);
+ runnable.run();
};
- doAnswer(submitAnswer).when(mockedExecutor).submit(any(Runnable.class));
- doAnswer(submitAnswer).when(mockedExecutor).submit(any(Callable.class));
- return mockedExecutor;
}
void assertSubmittedTasksSize(final int taskCount) {
- assertEquals(taskCount, this.submittedTasksToExecutor.size());
+ assertEquals(taskCount, submittedTasksToExecutor.size());
}
}
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.opendaylight.protocol.util.CheckTestUtil.checkNotPresentOperational;
@Test
public void testScheduleDependingInstructionToFail() throws Exception {
- try {
- testedProgrammingService.scheduleInstruction(getMockedSubmitInstructionInput("mockedSubmit",
- "dep1"));
- } catch (final SchedulerException e) {
- assertThat(e.getMessage(), containsString("Unknown dependency ID"));
- mockedNotificationServiceWrapper.assertNotificationsCount(0);
- return;
- }
- fail("Instruction schedule should fail on unresolved dependencies");
+ final var insn = getMockedSubmitInstructionInput("mockedSubmit", "dep1");
+ final var ex = assertThrows(SchedulerException.class, () -> testedProgrammingService.scheduleInstruction(insn));
+ assertThat(ex.getMessage(), containsString("Unknown dependency ID"));
+ mockedNotificationServiceWrapper.assertNotificationsCount(0);
}
@Test
Code Review / bgpcep.git / commitdiff