public Registration registerLifeCycleSource(final ItemLifeCycleSource lifeCycleSource) {
registry.add(lifeCycleSource);
- return new Registration() {
- @Override
- public void close() throws Exception {
- registry.remove(lifeCycleSource);
- }
- };
+ return () -> registry.remove(lifeCycleSource);
}
@Override
* @param version Openflow version
* @return injector
*/
- @VisibleForTesting
- static Function<Byte, Consumer<OFDeserializer<Action>>> createInjector(
+ private static Function<Byte, Consumer<OFDeserializer<Action>>> createInjector(
final DeserializerExtensionProvider provider,
final short version) {
- return code -> deserializer -> {
- provider.registerDeserializer(
- new MessageCodeExperimenterKey(version, code, Action.class, null),
- deserializer);
- };
+ return code -> deserializer -> provider.registerDeserializer(
+ new MessageCodeExperimenterKey(version, code, Action.class, null),
+ deserializer);
}
}
* @param version Openflow version
* @return injector
*/
- @VisibleForTesting
- static Function<Byte, Function<ActionPath, Consumer<OFDeserializer<Instruction>>>> createInjector(
+ private static Function<Byte, Function<ActionPath, Consumer<OFDeserializer<Instruction>>>> createInjector(
final DeserializerExtensionProvider provider,
final short version) {
- return code -> actionPath -> deserializer -> {
- provider.registerDeserializer((Objects.nonNull(actionPath)
- ? new MessageCodeActionExperimenterKey(version, code, Instruction.class, actionPath, null)
- : new MessageCodeExperimenterKey(version, code, Instruction.class, null)),
- deserializer);
- };
+ return code -> actionPath -> deserializer -> provider.registerDeserializer((Objects.nonNull(actionPath)
+ ? new MessageCodeActionExperimenterKey(version,
+ code,
+ Instruction.class,
+ actionPath,
+ null)
+ : new MessageCodeExperimenterKey(version, code, Instruction.class, null)),
+ deserializer);
}
}
* @param version Openflow version
* @return injector
*/
- @VisibleForTesting
- static Function<Integer, Consumer<OFDeserializer<? extends MultipartReplyBody>>> createInjector(
+ private static Function<Integer, Consumer<OFDeserializer<? extends MultipartReplyBody>>> createInjector(
final DeserializerExtensionProvider provider,
final short version) {
- return code -> deserializer -> {
- provider.registerDeserializer(
- new MessageCodeKey(version, code, MultipartReplyBody.class),
- deserializer);
- };
+ return code -> deserializer -> provider.registerDeserializer(
+ new MessageCodeKey(version, code, MultipartReplyBody.class),
+ deserializer);
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.opendaylight.openflowplugin.impl.util.BarrierUtil;
import org.opendaylight.openflowplugin.impl.util.GroupUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.BatchGroupInputUpdateGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.RemoveGroupsBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.RemoveGroupsBatchOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.SalGroupsBatchService;
resultsLot.add(JdkFutureAdapters.listenInPoolThread(salGroupService.updateGroup(updateGroupInput)));
}
- final Iterable<Group> groups = Iterables.transform(batchUpdateGroups, new Function<BatchUpdateGroups, Group>() {
- @Nullable
- @Override
- public Group apply(@Nullable final BatchUpdateGroups input) {
- return input.getUpdatedBatchedGroup();
- }
- }
- );
+ final Iterable<Group> groups = batchUpdateGroups.stream()
+ .map(BatchGroupInputUpdateGrouping::getUpdatedBatchedGroup)
+ .collect(Collectors.toList());
final ListenableFuture<RpcResult<List<BatchFailedGroupsOutput>>> commonResult =
Futures.transform(Futures.allAsList(resultsLot), GroupUtil.<UpdateGroupOutput>createCumulatingFunction(
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.opendaylight.openflowplugin.impl.util.BarrierUtil;
import org.opendaylight.openflowplugin.impl.util.MeterUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.AddMetersBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.AddMetersBatchOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.BatchMeterInputUpdateGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.RemoveMetersBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.RemoveMetersBatchOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.SalMetersBatchService;
resultsLot.add(JdkFutureAdapters.listenInPoolThread(salMeterService.updateMeter(updateMeterInput)));
}
- final Iterable<Meter> meters = Iterables.transform(batchUpdateMeters, new Function<BatchUpdateMeters, Meter>() {
- @Nullable
- @Override
- public Meter apply(@Nullable final BatchUpdateMeters input) {
- return input.getUpdatedBatchedMeter();
- }
- }
- );
+ final Iterable<Meter> meters = batchUpdateMeters.stream()
+ .map(BatchMeterInputUpdateGrouping::getUpdatedBatchedMeter)
+ .collect(Collectors.toList());
final ListenableFuture<RpcResult<List<BatchFailedMetersOutput>>> commonResult =
Futures.transform(Futures.allAsList(resultsLot), MeterUtil.<UpdateMeterOutput>createCumulativeFunction(
private static EventTimeCounter getOrCreateEventOfType(final String event,
final Map<String, EventTimeCounter> deviceEvents) {
- EventTimeCounter lookup = deviceEvents.get(event);
- if (null == lookup) {
- lookup = new EventTimeCounter();
- deviceEvents.put(event, lookup);
- }
- return lookup;
+ return deviceEvents.computeIfAbsent(event, k -> new EventTimeCounter());
}
private static Map<String, EventTimeCounter> getOrCreateCountersForDevice(final String deviceId) {
- Map<String, EventTimeCounter> lookup = DEVICES_EVENTS.get(deviceId);
- if (null == lookup) {
- lookup = new HashMap<>();
- DEVICES_EVENTS.put(deviceId, lookup);
- }
-
- return lookup;
+ return DEVICES_EVENTS.computeIfAbsent(deviceId, k -> new HashMap<>());
}
public static List<String> provideTimes() {
private static EventCounter getConnectionEvent(final Map<ConnectionStatus, EventCounter> sessionsConnectionEvents,
final ConnectionStatus connectionStatus) {
- EventCounter eventCounter = sessionsConnectionEvents.get(connectionStatus);
- if (null == eventCounter) {
- eventCounter = new EventCounter();
- sessionsConnectionEvents.put(connectionStatus, eventCounter);
- }
- return eventCounter;
+ return sessionsConnectionEvents.computeIfAbsent(connectionStatus, k -> new EventCounter());
}
private static Map<ConnectionStatus, EventCounter> getConnectionEvents(final String sessionId) {
- Map<ConnectionStatus, EventCounter> sessionConnectionEvents = SESSION_EVENTS.get(sessionId);
- if (null == sessionConnectionEvents) {
- sessionConnectionEvents = new HashMap<>();
- SESSION_EVENTS.put(sessionId, sessionConnectionEvents);
- }
- return sessionConnectionEvents;
+ return SESSION_EVENTS.computeIfAbsent(sessionId, k -> new HashMap<>());
}
// store input result and append barrier
final ListenableFuture<RpcResult<Void>> barrierResult = Futures.transformAsync(input,
- new AsyncFunction<RpcResult<T>, RpcResult<Void>>() {
- @Override
- public ListenableFuture<RpcResult<Void>> apply(@Nullable final RpcResult<T> interInput)
- throws Exception {
- resultPair.setLeft(interInput);
- final SendBarrierInput barrierInput = createSendBarrierInput(nodeRef);
- return JdkFutureAdapters.listenInPoolThread(transactionService.sendBarrier(barrierInput));
- }
+ interInput -> {
+ resultPair.setLeft(interInput);
+ final SendBarrierInput barrierInput = createSendBarrierInput(nodeRef);
+ return JdkFutureAdapters.listenInPoolThread(transactionService.sendBarrier(barrierInput));
});
// store barrier result and return initiated pair
final ListenableFuture<Pair<RpcResult<T>, RpcResult<Void>>> compositeResult = Futures.transform(
@RunWith(MockitoJUnitRunner.class)
public class HandshakeListenerImplTest {
- private final Short version = OFConstants.OFP_VERSION_1_3;
-
@Mock
private DeviceConnectedHandler deviceConnectedHandler;
@Mock
@Test
public void testOnHandshakeSuccessfull() throws Exception {
- handshakeListener.onHandshakeSuccessful(features, version);
+ handshakeListener.onHandshakeSuccessful(features, OFConstants.OFP_VERSION_1_3);
Mockito.verify(connectionContextSpy).changeStateToWorking();
Mockito.verify(connectionContextSpy).setFeatures(Matchers.any(FeaturesReply.class));
Mockito.verify(connectionContextSpy).setNodeId(nodeIdCaptor.capture());
Mockito.reset(deviceProcessor);
- cleanUpCheck = new Runnable() {
- @Override
- public void run() {
- Mockito.verify(deviceProcessor, VerificationModeFactory.noMoreInteractions())
- .processReply(xidCaptor.capture(), mmCaptor.capture());
- Assert.assertEquals(xid, xidCaptor.getValue().getValue());
- }
+ cleanUpCheck = () -> {
+ Mockito.verify(deviceProcessor, VerificationModeFactory.noMoreInteractions())
+ .processReply(xidCaptor.capture(), mmCaptor.capture());
+ Assert.assertEquals(xid, xidCaptor.getValue().getValue());
};
}
Mockito.reset(deviceProcessor);
- cleanUpCheck = new Runnable() {
- @Override
- public void run() {
- Mockito.verify(deviceProcessor, VerificationModeFactory.noMoreInteractions())
- .processReply(xidCaptor.capture(), mmCaptor.capture());
- Assert.assertEquals(xid, xidCaptor.getValue().getValue());
- }
+ cleanUpCheck = () -> {
+ Mockito.verify(deviceProcessor, VerificationModeFactory.noMoreInteractions())
+ .processReply(xidCaptor.capture(), mmCaptor.capture());
+ Assert.assertEquals(xid, xidCaptor.getValue().getValue());
};
}
.build())
.build();
- assertProperty(property, out -> {
- assertEquals(out.readUnsignedByte(), tableId);
- });
+ assertProperty(property, out -> assertEquals(out.readUnsignedByte(), tableId));
}
@Override
.build())
.build();
- assertProperty(property, out -> {
- assertEquals(out.readUnsignedByte(), tableId);
- });
+ assertProperty(property, out -> assertEquals(out.readUnsignedByte(), tableId));
}
@Override
@Mock
private BindingAwareBroker.RoutedRpcRegistration<TestRpcService> routedRpcReg;
- private Class<TestRpcService> serviceClass;
@Mock
private NotificationPublishService notificationPublishService;
@Mock
@Test
public void testClose() {
- serviceClass = TestRpcService.class;
+ Class<TestRpcService> serviceClass = TestRpcService.class;
when(routedRpcReg.getServiceType()).thenReturn(serviceClass);
rpcContext.registerRpcServiceImplementation(TestRpcService.class, serviceInstance);
rpcContext.close();
private NodeId testNodeId = new NodeId(Uri.getDefaultInstance("openflow:1"));
- private static short testVersion = 4;
-
private static long testXid = 100L;
private static final String ROLEREQUESTFAILED = org.opendaylight.yang.gen.v1.urn
MockitoAnnotations.initMocks(this);
Mockito.when(mockDeviceInfo.getNodeId()).thenReturn(testNodeId);
Mockito.when(mockDeviceInfo.getDatapathId()).thenReturn(BigInteger.TEN);
+ short testVersion = 4;
Mockito.when(mockFeaturesOutput.getVersion()).thenReturn(testVersion);
Mockito.when(mockDeviceContext.getDeviceState()).thenReturn(mockDeviceState);
Mockito.when(mockDeviceContext.getDeviceInfo()).thenReturn(mockDeviceInfo);
public void setup() {
handleResultFuture = SettableFuture.create();
when(mockedRequestContext.getFuture()).thenReturn(handleResultFuture);
- Mockito.doAnswer(new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
- final FutureCallback<OfHeader> callback = (FutureCallback<OfHeader>) invocation.getArguments()[2];
- callback.onSuccess(null);
- return null;
- }
+ Mockito.doAnswer((Answer<Void>) invocation -> {
+ final FutureCallback<OfHeader> callback = (FutureCallback<OfHeader>) invocation.getArguments()[2];
+ callback.onSuccess(null);
+ return null;
})
.when(mockedOutboundQueue).commitEntry(
Matchers.anyLong(), Matchers.<OfHeader>any(), Matchers.<FutureCallback<OfHeader>>any());
@Test
public void testUpdateTableFail1() throws ExecutionException, InterruptedException {
- Mockito.doAnswer(new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
- final RpcResult<List<MultipartReply>> rpcResult =
- RpcResultBuilder.<List<MultipartReply>>failed().build();
- handleResultFuture.set(rpcResult);
- return null;
- }
+ Mockito.doAnswer((Answer<Void>) invocation -> {
+ final RpcResult<List<MultipartReply>> rpcResult =
+ RpcResultBuilder.<List<MultipartReply>>failed().build();
+ handleResultFuture.set(rpcResult);
+ return null;
}).when(multiMessageCollector).endCollecting(Matchers.<EventIdentifier>any());
final Future<RpcResult<UpdateTableOutput>> rpcResultFuture = salTableService.updateTable(prepareUpdateTable());
@Test
public void testUpdateTableFail2() throws ExecutionException, InterruptedException {
- Mockito.doAnswer(new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
- final RpcResult<List<MultipartReply>> rpcResult =
- RpcResultBuilder.success(Collections.<MultipartReply>emptyList())
- .build();
- handleResultFuture.set(rpcResult);
- return null;
- }
+ Mockito.doAnswer((Answer<Void>) invocation -> {
+ final RpcResult<List<MultipartReply>> rpcResult =
+ RpcResultBuilder.success(Collections.<MultipartReply>emptyList())
+ .build();
+ handleResultFuture.set(rpcResult);
+ return null;
}).when(multiMessageCollector).endCollecting(Matchers.<EventIdentifier>any());
final Future<RpcResult<UpdateTableOutput>> rpcResultFuture = salTableService.updateTable(prepareUpdateTable());
@Test
public void testUpdateTableSuccess() throws ExecutionException, InterruptedException {
- Mockito.doAnswer(new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
- TableFeaturesBuilder tableFeaturesBld = new TableFeaturesBuilder()
- .setTableId((short) 0)
- .setName("Zafod")
- .setMaxEntries(42L)
- .setTableFeatureProperties(Collections.<TableFeatureProperties>emptyList());
- MultipartReplyTableFeaturesBuilder mpTableFeaturesBld = new MultipartReplyTableFeaturesBuilder()
- .setTableFeatures(Collections.singletonList(tableFeaturesBld.build()));
- MultipartReplyTableFeaturesCaseBuilder mpBodyBld = new MultipartReplyTableFeaturesCaseBuilder()
- .setMultipartReplyTableFeatures(mpTableFeaturesBld.build());
- MultipartReplyMessageBuilder mpResultBld = new MultipartReplyMessageBuilder()
- .setType(MultipartType.OFPMPTABLEFEATURES)
- .setMultipartReplyBody(mpBodyBld.build())
- .setXid(21L);
- final RpcResult<List<MultipartReply>> rpcResult = RpcResultBuilder
- .success(Collections.singletonList((MultipartReply) mpResultBld.build()))
- .build();
- handleResultFuture.set(rpcResult);
- return null;
- }
+ Mockito.doAnswer((Answer<Void>) invocation -> {
+ TableFeaturesBuilder tableFeaturesBld = new TableFeaturesBuilder()
+ .setTableId((short) 0)
+ .setName("Zafod")
+ .setMaxEntries(42L)
+ .setTableFeatureProperties(Collections.<TableFeatureProperties>emptyList());
+ MultipartReplyTableFeaturesBuilder mpTableFeaturesBld = new MultipartReplyTableFeaturesBuilder()
+ .setTableFeatures(Collections.singletonList(tableFeaturesBld.build()));
+ MultipartReplyTableFeaturesCaseBuilder mpBodyBld = new MultipartReplyTableFeaturesCaseBuilder()
+ .setMultipartReplyTableFeatures(mpTableFeaturesBld.build());
+ MultipartReplyMessageBuilder mpResultBld = new MultipartReplyMessageBuilder()
+ .setType(MultipartType.OFPMPTABLEFEATURES)
+ .setMultipartReplyBody(mpBodyBld.build())
+ .setXid(21L);
+ final RpcResult<List<MultipartReply>> rpcResult = RpcResultBuilder
+ .success(Collections.singletonList((MultipartReply) mpResultBld.build()))
+ .build();
+ handleResultFuture.set(rpcResult);
+ return null;
}).when(multiMessageCollector).endCollecting(Matchers.<EventIdentifier>any());
final Future<RpcResult<UpdateTableOutput>> rpcResultFuture = salTableService.updateTable(prepareUpdateTable());
//NOOP
}
};
- final Answer closeRequestFutureAnswer = new Answer() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
- rqContext.setResult(rpcResult);
- rqContext.close();
- return null;
- }
+ final Answer closeRequestFutureAnswer = invocation -> {
+ rqContext.setResult(rpcResult);
+ rqContext.close();
+ return null;
};
Mockito.when(rqContextStack.<Object>createRequestContext()).thenReturn(rqContext);
public static final NodeId NODE_ID = new NodeId("unit-test-node:123");
- protected final Answer<Void> answerVoidToCallback = new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
- final FutureCallback<OfHeader> callback = (FutureCallback<OfHeader>) (invocation.getArguments()[2]);
- callback.onSuccess(null);
- return null;
- }
+ protected final Answer<Void> answerVoidToCallback = invocation -> {
+ final FutureCallback<OfHeader> callback = (FutureCallback<OfHeader>) (invocation.getArguments()[2]);
+ callback.onSuccess(null);
+ return null;
};
@Before
@Captor
private ArgumentCaptor<MultipartRequestInput> requestInput;
- private AbstractRequestContext<Object> rqContext;
-
private OpendaylightFlowStatisticsServiceImpl flowStatisticsService;
public void setUp() {
flowStatisticsService =
OpendaylightFlowStatisticsServiceImpl.createWithOook(rqContextStack, deviceContext, convertorManager);
- rqContext = new AbstractRequestContext<Object>(42L) {
+ AbstractRequestContext<Object> rqContext = new AbstractRequestContext<Object>(42L) {
@Override
public void close() {
//NOOP
public void testGetAggregateFlowStatisticsFromFlowTableForGivenMatch() throws Exception {
Mockito.doAnswer(answerVoidToCallback).when(outboundQueueProvider)
.commitEntry(Matchers.eq(42L), requestInput.capture(), Matchers.any(FutureCallback.class));
- Mockito.doAnswer(new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
- final MultipartReplyMessageBuilder messageBuilder = new MultipartReplyMessageBuilder()
- .setVersion(OFConstants.OFP_VERSION_1_3);
+ Mockito.doAnswer((Answer<Void>) invocation -> {
+ final MultipartReplyMessageBuilder messageBuilder = new MultipartReplyMessageBuilder()
+ .setVersion(OFConstants.OFP_VERSION_1_3);
- rqContextMp.setResult(RpcResultBuilder
- .success(Collections.<MultipartReply>singletonList(messageBuilder.build()))
- .build());
- return null;
- }
+ rqContextMp.setResult(RpcResultBuilder
+ .success(Collections.<MultipartReply>singletonList(messageBuilder.build()))
+ .build());
+ return null;
}).when(multiMsgCollector).endCollecting(Matchers.any(EventIdentifier.class));
Mockito.when(translator.translate(
Matchers.any(MultipartReply.class), Matchers.same(deviceInfo), Matchers.isNull())
//NOOP
}
};
- final Answer closeRequestFutureAnswer = new Answer() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
- rqContext.setResult(rpcResult);
- rqContext.close();
- return null;
- }
+ final Answer closeRequestFutureAnswer = invocation -> {
+ rqContext.setResult(rpcResult);
+ rqContext.close();
+ return null;
};
Mockito.when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
@Mock
private FlowWildcardsV10 flowWildcards;
- private KeyedInstanceIdentifier<Node, NodeKey> nodeId;
-
@Before
public void setUp() throws Exception {
- nodeId = InstanceIdentifier.create(Nodes.class)
+ KeyedInstanceIdentifier<Node, NodeKey> nodeId = InstanceIdentifier.create(Nodes.class)
.child(Node.class, new NodeKey(new NodeId("dummyNodeId")));
final ConvertorManager convertorManager = ConvertorManagerFactory.createDefaultManager();
Code Review / openflowplugin.git / commitdiff