Examples with DeviceInfo org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo used on opensource projects

Example 6 with DeviceInfo

use of org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo in project openflowplugin by opendaylight.

the class AbstractCompatibleStatServiceTest method setUp.

@Override
public void setUp() {
    rqContext = new AbstractRequestContext<Object>(42L) {

        @Override
        public void close() {
        // NOOP
        }
    };
    final Answer closeRequestFutureAnswer = invocation -> {
        rqContext.setResult(rpcResult);
        rqContext.close();
        return null;
    };
    Mockito.when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
    Mockito.when(rqContextStack.<Object>createRequestContext()).thenReturn(rqContext);
    Mockito.when(deviceContext.getDeviceState()).thenReturn(deviceState);
    Mockito.when(deviceContext.getDeviceInfo()).thenReturn(deviceInfo);
    Mockito.when(deviceInfo.getNodeId()).thenReturn(NODE_ID);
    Mockito.when(deviceInfo.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
    Mockito.doAnswer(closeRequestFutureAnswer).when(multiMsgCollector).endCollecting(null);
    Mockito.doAnswer(closeRequestFutureAnswer).when(multiMsgCollector).endCollecting(Matchers.any(EventIdentifier.class));
    Mockito.doAnswer(answerVoidToCallback).when(outboundQueueProvider).commitEntry(Matchers.eq(42L), requestInput.capture(), Matchers.any(FutureCallback.class));
    Mockito.when(translatorLibrary.lookupTranslator(Matchers.any(TranslatorKey.class))).thenReturn(translator);
    service = AggregateFlowsInTableService.createWithOook(rqContextStack, deviceContext, new AtomicLong(20L));
}

Example 7 with DeviceInfo

use of org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo in project openflowplugin by opendaylight.

the class DeviceContextImplTest method setUp.

@Before
public void setUp() throws Exception {
    final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture = Futures.immediateCheckedFuture(Optional.<Node>absent());
    Mockito.when(readTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent)).thenReturn(noExistNodeFuture);
    Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readTx);
    Mockito.when(dataBroker.createTransactionChain(Mockito.any(TransactionChainManager.class))).thenReturn(txChainFactory);
    Mockito.when(deviceInfo.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent);
    Mockito.when(deviceInfo.getNodeId()).thenReturn(nodeId);
    Mockito.when(deviceInfo.getDatapathId()).thenReturn(BigInteger.ONE);
    final SettableFuture<RpcResult<GetAsyncReply>> settableFuture = SettableFuture.create();
    final SettableFuture<RpcResult<MultipartReply>> settableFutureMultiReply = SettableFuture.create();
    Mockito.when(requestContext.getFuture()).thenReturn(settableFuture);
    Mockito.doAnswer(invocation -> {
        settableFuture.set((RpcResult<GetAsyncReply>) invocation.getArguments()[0]);
        return null;
    }).when(requestContext).setResult(any(RpcResult.class));
    Mockito.when(requestContextMultiReply.getFuture()).thenReturn(settableFutureMultiReply);
    Mockito.doAnswer(invocation -> {
        settableFutureMultiReply.set((RpcResult<MultipartReply>) invocation.getArguments()[0]);
        return null;
    }).when(requestContextMultiReply).setResult(any(RpcResult.class));
    Mockito.when(txChainFactory.newReadWriteTransaction()).thenReturn(writeTx);
    Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readTx);
    Mockito.when(connectionContext.getOutboundQueueProvider()).thenReturn(outboundQueueProvider);
    Mockito.when(connectionContext.getConnectionAdapter()).thenReturn(connectionAdapter);
    Mockito.when(connectionContext.getDeviceInfo()).thenReturn(deviceInfo);
    final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
    when(connectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
    when(connectionContext.getFeatures().getCapabilities()).thenReturn(mock(Capabilities.class));
    Mockito.when(deviceInfo.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
    Mockito.when(featuresOutput.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
    Mockito.when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
    Mockito.when(contextChainHolder.getContextChain(deviceInfo)).thenReturn(contextChain);
    Mockito.when(contextChain.isMastered(ContextChainMastershipState.CHECK, false)).thenReturn(true);
    final PacketReceived packetReceived = new PacketReceivedBuilder().setMatch(new org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.packet.received.MatchBuilder().setInPort(new NodeConnectorId("openflow:1:LOCAL")).build()).build();
    Mockito.when(messageTranslatorPacketReceived.translate(any(Object.class), any(DeviceInfo.class), any(Object.class))).thenReturn(packetReceived);
    Mockito.when(messageTranslatorFlowCapableNodeConnector.translate(any(Object.class), any(DeviceInfo.class), any(Object.class))).thenReturn(mock(FlowCapableNodeConnector.class));
    Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, PacketIn.class.getName())))).thenReturn(messageTranslatorPacketReceived);
    Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, PortGrouping.class.getName())))).thenReturn(messageTranslatorFlowCapableNodeConnector);
    Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, FlowRemoved.class.getName())))).thenReturn(messageTranslatorFlowRemoved);
    Mockito.when(abstractDeviceInitializer.initialize(any(), anyBoolean(), anyBoolean(), any(), any())).thenReturn(Futures.immediateFuture(null));
    final java.util.Optional<AbstractDeviceInitializer> deviceInitializer = java.util.Optional.of(this.abstractDeviceInitializer);
    Mockito.when(deviceInitializerProvider.lookup(OFConstants.OFP_VERSION_1_3)).thenReturn(deviceInitializer);
    Mockito.when(salRoleService.setRole(any())).thenReturn(Futures.immediateFuture(null));
    deviceContext = new DeviceContextImpl(connectionContext, dataBroker, messageSpy, translatorLibrary, convertorExecutor, false, timer, false, deviceInitializerProvider, true, false, contextChainHolder);
    ((DeviceContextImpl) deviceContext).lazyTransactionManagerInitialization();
    deviceContextSpy = Mockito.spy(deviceContext);
    xid = new Xid(atomicLong.incrementAndGet());
    xidMulti = new Xid(atomicLong.incrementAndGet());
    Mockito.doNothing().when(deviceContextSpy).writeToTransaction(any(), any(), any());
}

Example 8 with DeviceInfo

use of org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo in project openflowplugin by opendaylight.

the class RoleManagerImpl method createContext.

@Override
public RoleContext createContext(@Nonnull final DeviceContext deviceContext) {
    final DeviceInfo deviceInfo = deviceContext.getDeviceInfo();
    final RoleContextImpl roleContext = new RoleContextImpl(deviceContext.getDeviceInfo(), timer, CHECK_ROLE_MASTER_TIMEOUT, config);
    roleContext.setRoleService(new SalRoleServiceImpl(roleContext, deviceContext));
    contexts.put(deviceInfo, roleContext);
    return roleContext;
}

Example 9 with DeviceInfo

use of org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo in project openflowplugin by opendaylight.

the class MultipartReplyTranslatorTest method prepareMocks.

private MultipartReplyMessage prepareMocks(DeviceContext mockedDeviceContext, MultipartReplyBody multipartReplyBody, final MultipartType multipartType) {
    ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
    FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
    when(mockedFeaturesReply.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
    when(mockedFeaturesReply.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
    DeviceInfo deviceInfo = mock(DeviceInfo.class);
    when(deviceInfo.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
    when(deviceInfo.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
    when(mockedDeviceContext.getDeviceInfo()).thenReturn(deviceInfo);
    when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
    when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockedConnectionContext);
    MultipartReplyMessage multipartReplyMessage = mock(MultipartReplyMessage.class);
    when(multipartReplyMessage.getType()).thenReturn(multipartType);
    when(multipartReplyMessage.getFlags()).thenReturn(new MultipartRequestFlags(true));
    when(multipartReplyMessage.getXid()).thenReturn(DUMMY_XID);
    when(multipartReplyMessage.getMultipartReplyBody()).thenReturn(multipartReplyBody);
    return multipartReplyMessage;
}

Example 10 with DeviceInfo

use of org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo in project openflowplugin by opendaylight.

the class ContextChainHolderImpl method deviceConnected.

@Override
public ConnectionStatus deviceConnected(final ConnectionContext connectionContext) throws Exception {
    final DeviceInfo deviceInfo = connectionContext.getDeviceInfo();
    final ContextChain contextChain = contextChainMap.get(deviceInfo);
    final FeaturesReply featuresReply = connectionContext.getFeatures();
    final Short auxiliaryId = featuresReply != null ? featuresReply.getAuxiliaryId() : null;
    if (auxiliaryId != null && auxiliaryId != 0) {
        if (contextChain == null) {
            LOG.warn("An auxiliary connection for device {}, but no primary connection. Refusing connection.", deviceInfo);
            return ConnectionStatus.REFUSING_AUXILIARY_CONNECTION;
        } else {
            if (contextChain.addAuxiliaryConnection(connectionContext)) {
                LOG.info("An auxiliary connection was added to device: {}", deviceInfo);
                return ConnectionStatus.MAY_CONTINUE;
            } else {
                LOG.warn("Not able to add auxiliary connection to the device {}", deviceInfo);
                return ConnectionStatus.REFUSING_AUXILIARY_CONNECTION;
            }
        }
    } else {
        LOG.info("Device {} connected.", deviceInfo);
        final boolean contextExists = contextChain != null;
        final boolean isClosing = contextExists && contextChain.isClosing();
        if (!isClosing && connectingDevices.putIfAbsent(deviceInfo, connectionContext) != null) {
            LOG.warn("Device {} is already trying to connect, wait until succeeded or disconnected.", deviceInfo);
            return ConnectionStatus.ALREADY_CONNECTED;
        }
        if (contextExists) {
            if (isClosing) {
                LOG.warn("Device {} is already in termination state, closing all incoming connections.", deviceInfo);
                return ConnectionStatus.CLOSING;
            }
            LOG.warn("Device {} already connected. Closing previous connection", deviceInfo);
            destroyContextChain(deviceInfo);
            LOG.info("Old connection dropped, creating new context chain for device {}", deviceInfo);
            createContextChain(connectionContext);
        } else {
            LOG.info("No context chain found for device: {}, creating new.", deviceInfo);
            createContextChain(connectionContext);
        }
        return ConnectionStatus.MAY_CONTINUE;
    }
}