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

Example 1 with DeviceInfo

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

the class ContextChainHolderImpl method onDeviceDisconnected.

@Override
public void onDeviceDisconnected(final ConnectionContext connectionContext) {
    final DeviceInfo deviceInfo = connectionContext.getDeviceInfo();
    Optional.ofNullable(connectionContext.getDeviceInfo()).map(contextChainMap::get).ifPresent(contextChain -> {
        if (contextChain.auxiliaryConnectionDropped(connectionContext)) {
            LOG.info("Auxiliary connection from device {} disconnected.", deviceInfo);
        } else {
            LOG.info("Device {} disconnected.", deviceInfo);
            destroyContextChain(deviceInfo);
        }
    });
}

Example 2 with DeviceInfo

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

the class ContextChainHolderImpl method createContextChain.

@VisibleForTesting
void createContextChain(final ConnectionContext connectionContext) {
    final DeviceInfo deviceInfo = connectionContext.getDeviceInfo();
    final DeviceContext deviceContext = deviceManager.createContext(connectionContext);
    deviceContext.registerMastershipWatcher(this);
    LOG.debug("Device" + CONTEXT_CREATED_FOR_CONNECTION, deviceInfo);
    final RpcContext rpcContext = rpcManager.createContext(deviceContext);
    rpcContext.registerMastershipWatcher(this);
    LOG.debug("RPC" + CONTEXT_CREATED_FOR_CONNECTION, deviceInfo);
    final StatisticsContext statisticsContext = statisticsManager.createContext(deviceContext, ownershipChangeListener.isReconciliationFrameworkRegistered());
    statisticsContext.registerMastershipWatcher(this);
    LOG.debug("Statistics" + CONTEXT_CREATED_FOR_CONNECTION, deviceInfo);
    final RoleContext roleContext = roleManager.createContext(deviceContext);
    roleContext.registerMastershipWatcher(this);
    LOG.debug("Role" + CONTEXT_CREATED_FOR_CONNECTION, deviceInfo);
    final ContextChain contextChain = new ContextChainImpl(this, connectionContext, executorService);
    contextChain.registerDeviceRemovedHandler(deviceManager);
    contextChain.registerDeviceRemovedHandler(rpcManager);
    contextChain.registerDeviceRemovedHandler(statisticsManager);
    contextChain.registerDeviceRemovedHandler(roleManager);
    contextChain.registerDeviceRemovedHandler(this);
    contextChain.addContext(deviceContext);
    contextChain.addContext(rpcContext);
    contextChain.addContext(statisticsContext);
    contextChain.addContext(roleContext);
    contextChainMap.put(deviceInfo, contextChain);
    connectingDevices.remove(deviceInfo);
    LOG.debug("Context chain" + CONTEXT_CREATED_FOR_CONNECTION, deviceInfo);
    deviceContext.onPublished();
    contextChain.registerServices(singletonServiceProvider);
}

Example 3 with DeviceInfo

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

the class OF10DeviceInitializer method writePhyPortInformation.

@SuppressWarnings("checkstyle:IllegalCatch")
private static void writePhyPortInformation(final DeviceContext deviceContext) {
    final DeviceInfo deviceInfo = deviceContext.getDeviceInfo();
    final ConnectionContext connectionContext = deviceContext.getPrimaryConnectionContext();
    final MessageTranslator<PortGrouping, FlowCapableNodeConnector> translator = deviceContext.oook().lookupTranslator(new TranslatorKey(deviceInfo.getVersion(), PortGrouping.class.getName()));
    connectionContext.getFeatures().getPhyPort().forEach(port -> {
        final NodeConnectorId nodeConnectorId = InventoryDataServiceUtil.nodeConnectorIdfromDatapathPortNo(deviceInfo.getDatapathId(), port.getPortNo(), OpenflowVersion.get(deviceInfo.getVersion()));
        try {
            deviceContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, deviceInfo.getNodeInstanceIdentifier().child(NodeConnector.class, new NodeConnectorKey(nodeConnectorId)), new NodeConnectorBuilder().setId(nodeConnectorId).addAugmentation(FlowCapableNodeConnector.class, translator.translate(port, deviceInfo, null)).addAugmentation(FlowCapableNodeConnectorStatisticsData.class, new FlowCapableNodeConnectorStatisticsDataBuilder().build()).build());
        } catch (final Exception e) {
            LOG.debug("Failed to write node {} to DS ", deviceInfo, e);
        }
    });
}

Example 4 with DeviceInfo

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

the class OF10DeviceInitializer method initializeNodeInformation.

@Override
protected Future<Void> initializeNodeInformation(@Nonnull final DeviceContext deviceContext, final boolean switchFeaturesMandatory, final boolean skipTableFeatures, @Nullable final MultipartWriterProvider multipartWriterProvider, @Nullable final ConvertorExecutor convertorExecutor) {
    final ConnectionContext connectionContext = Preconditions.checkNotNull(deviceContext.getPrimaryConnectionContext());
    final DeviceState deviceState = Preconditions.checkNotNull(deviceContext.getDeviceState());
    final DeviceInfo deviceInfo = Preconditions.checkNotNull(deviceContext.getDeviceInfo());
    final CapabilitiesV10 capabilitiesV10 = connectionContext.getFeatures().getCapabilitiesV10();
    // Set capabilities for this device based on capabilities of connection context
    LOG.debug("Setting capabilities for device {}", deviceInfo);
    DeviceStateUtil.setDeviceStateBasedOnV10Capabilities(deviceState, capabilitiesV10);
    final ListenableFuture<Boolean> future = requestMultipart(MultipartType.OFPMPDESC, deviceContext);
    Futures.addCallback(future, new FutureCallback<Boolean>() {

        @Override
        public void onSuccess(@Nullable final Boolean result) {
            if (Boolean.TRUE.equals(result)) {
                LOG.debug("Creating empty flow capable node: {}", deviceInfo);
                makeEmptyFlowCapableNode(deviceContext, deviceInfo);
                LOG.debug("Creating empty tables for {}", deviceInfo);
                DeviceInitializationUtil.makeEmptyTables(deviceContext, deviceInfo, deviceContext.getPrimaryConnectionContext().getFeatures().getTables());
            }
        }

        @Override
        public void onFailure(@Nonnull final Throwable throwable) {
            LOG.warn("Error occurred in preparation node {} for protocol 1.0", deviceInfo);
            LOG.trace("Error for node {} : ", deviceInfo, throwable);
        }
    }, MoreExecutors.directExecutor());
    return Futures.transform(future, new Function<Boolean, Void>() {

        @Nullable
        @Override
        public Void apply(@Nullable final Boolean input) {
            LOG.debug("Writing physical port information for {}", deviceInfo);
            writePhyPortInformation(deviceContext);
            return null;
        }
    }, MoreExecutors.directExecutor());
}

Example 5 with DeviceInfo

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

the class OF13DeviceInitializer method initializeNodeInformation.

@Override
protected Future<Void> initializeNodeInformation(@Nonnull final DeviceContext deviceContext, final boolean switchFeaturesMandatory, final boolean skipTableFeatures, @Nullable final MultipartWriterProvider multipartWriterProvider, @Nullable final ConvertorExecutor convertorExecutor) {
    final ConnectionContext connectionContext = Preconditions.checkNotNull(deviceContext.getPrimaryConnectionContext());
    final DeviceState deviceState = Preconditions.checkNotNull(deviceContext.getDeviceState());
    final DeviceInfo deviceInfo = Preconditions.checkNotNull(deviceContext.getDeviceInfo());
    final Capabilities capabilities = connectionContext.getFeatures().getCapabilities();
    LOG.debug("Setting capabilities for device {}", deviceInfo);
    DeviceStateUtil.setDeviceStateBasedOnV13Capabilities(deviceState, capabilities);
    // First process description reply, write data to DS and write consequent data if successful
    return Futures.transformAsync(requestMultipart(MultipartType.OFPMPDESC, deviceContext), (AsyncFunction<RpcResult<List<OfHeader>>, Void>) input -> {
        translateAndWriteResult(MultipartType.OFPMPDESC, input.getResult(), deviceContext, multipartWriterProvider, convertorExecutor);
        final List<ListenableFuture<RpcResult<List<OfHeader>>>> futures = new ArrayList<>();
        futures.add(requestAndProcessMultipart(MultipartType.OFPMPMETERFEATURES, deviceContext, skipTableFeatures, multipartWriterProvider, convertorExecutor));
        futures.add(requestAndProcessMultipart(MultipartType.OFPMPGROUPFEATURES, deviceContext, skipTableFeatures, multipartWriterProvider, convertorExecutor));
        futures.add(requestAndProcessMultipart(MultipartType.OFPMPTABLEFEATURES, deviceContext, skipTableFeatures, multipartWriterProvider, convertorExecutor));
        futures.add(requestAndProcessMultipart(MultipartType.OFPMPPORTDESC, deviceContext, skipTableFeatures, multipartWriterProvider, convertorExecutor));
        return Futures.transform(switchFeaturesMandatory ? Futures.allAsList(futures) : Futures.successfulAsList(futures), new Function<List<RpcResult<List<OfHeader>>>, Void>() {

            @Nullable
            @Override
            public Void apply(@Nullable final List<RpcResult<List<OfHeader>>> input) {
                LOG.info("Static node {} successfully finished collecting", deviceContext.getDeviceInfo());
                return null;
            }
        }, MoreExecutors.directExecutor());
    }, MoreExecutors.directExecutor());
}