2 * Copyright (c) 2017 Pantheon Technologies s.r.o. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.openflowplugin.impl.device.initialization;
10 import com.google.common.base.Preconditions;
11 import com.google.common.util.concurrent.FutureCallback;
12 import com.google.common.util.concurrent.Futures;
13 import com.google.common.util.concurrent.ListenableFuture;
14 import com.google.common.util.concurrent.MoreExecutors;
15 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
16 import org.eclipse.jdt.annotation.NonNull;
17 import org.eclipse.jdt.annotation.Nullable;
18 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
19 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
20 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
21 import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
22 import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
23 import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator;
24 import org.opendaylight.openflowplugin.api.openflow.device.TxFacade;
25 import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey;
26 import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
27 import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProvider;
28 import org.opendaylight.openflowplugin.impl.services.multilayer.MultiLayerMultipartCollectorService;
29 import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerMultipartCollectorService;
30 import org.opendaylight.openflowplugin.impl.util.DeviceInitializationUtil;
31 import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
32 import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
33 import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.CapabilitiesV10;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsDataBuilder;
45 import org.opendaylight.yangtools.yang.common.RpcResult;
46 import org.slf4j.Logger;
47 import org.slf4j.LoggerFactory;
49 public class OF10DeviceInitializer extends AbstractDeviceInitializer {
51 private static final Logger LOG = LoggerFactory.getLogger(OF10DeviceInitializer.class);
54 protected ListenableFuture<Void> initializeNodeInformation(@NonNull final DeviceContext deviceContext,
55 final boolean switchFeaturesMandatory,
56 final boolean skipTableFeatures,
57 @Nullable final MultipartWriterProvider multipartWriterProvider,
58 @Nullable final ConvertorExecutor convertorExecutor) {
59 final ConnectionContext connectionContext =
60 Preconditions.checkNotNull(deviceContext.getPrimaryConnectionContext());
61 final DeviceState deviceState = Preconditions.checkNotNull(deviceContext.getDeviceState());
62 final DeviceInfo deviceInfo = Preconditions.checkNotNull(deviceContext.getDeviceInfo());
63 final CapabilitiesV10 capabilitiesV10 = connectionContext.getFeatures().getCapabilitiesV10();
65 // Set capabilities for this device based on capabilities of connection context
66 LOG.debug("Setting capabilities for device {}", deviceInfo);
67 DeviceStateUtil.setDeviceStateBasedOnV10Capabilities(deviceState, capabilitiesV10);
68 final ListenableFuture<Boolean> future = requestMultipart(MultipartType.OFPMPDESC, deviceContext);
70 Futures.addCallback(future, new FutureCallback<Boolean>() {
72 public void onSuccess(final Boolean result) {
73 if (Boolean.TRUE.equals(result)) {
74 LOG.debug("Creating empty flow capable node: {}", deviceInfo);
75 makeEmptyFlowCapableNode(deviceContext, deviceInfo);
77 LOG.debug("Creating empty tables for {}", deviceInfo);
78 DeviceInitializationUtil.makeEmptyTables(
81 deviceContext.getPrimaryConnectionContext().getFeatures().getTables().toJava());
86 public void onFailure(final Throwable throwable) {
87 LOG.warn("Error occurred in preparation node {} for protocol 1.0", deviceInfo);
88 LOG.trace("Error for node {} : ", deviceInfo, throwable);
90 }, MoreExecutors.directExecutor());
92 return Futures.transform(future, input -> {
93 LOG.debug("Writing physical port information for {}", deviceInfo);
94 writePhyPortInformation(deviceContext);
96 }, MoreExecutors.directExecutor());
99 @SuppressWarnings("checkstyle:IllegalCatch")
100 private static void writePhyPortInformation(final DeviceContext deviceContext) {
101 final DeviceInfo deviceInfo = deviceContext.getDeviceInfo();
102 final ConnectionContext connectionContext = deviceContext.getPrimaryConnectionContext();
103 final MessageTranslator<PortGrouping, FlowCapableNodeConnector> translator = deviceContext
105 .lookupTranslator(new TranslatorKey(deviceInfo.getVersion(), PortGrouping.class.getName()));
107 connectionContext.getFeatures().getPhyPort().forEach(port -> {
108 final NodeConnectorId nodeConnectorId = InventoryDataServiceUtil.nodeConnectorIdfromDatapathPortNo(
109 deviceInfo.getDatapathId(),
111 OpenflowVersion.get(deviceInfo.getVersion()));
113 final NodeConnectorBuilder connectorBuilder = new NodeConnectorBuilder()
114 .setId(nodeConnectorId)
115 .addAugmentation(new FlowCapableNodeConnectorStatisticsDataBuilder().build());
116 final FlowCapableNodeConnector augment = translator.translate(port, deviceInfo, null);
117 if (augment != null) {
118 connectorBuilder.addAugmentation(augment);
122 deviceContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
124 .getNodeInstanceIdentifier()
125 .child(NodeConnector.class, new NodeConnectorKey(nodeConnectorId)),
126 connectorBuilder.build());
127 } catch (final Exception e) {
128 LOG.debug("Failed to write node {} to DS ", deviceInfo, e);
133 @SuppressWarnings("checkstyle:IllegalCatch")
134 @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
135 justification = "https://github.com/spotbugs/spotbugs/issues/811")
136 private static void makeEmptyFlowCapableNode(final TxFacade txFacade, final DeviceInfo deviceInfo) {
138 txFacade.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
140 .getNodeInstanceIdentifier()
141 .augmentation(FlowCapableNode.class),
142 new FlowCapableNodeBuilder().build());
143 } catch (final Exception e) {
144 LOG.debug("Failed to write empty node {} to DS ", deviceInfo, e);
148 private static ListenableFuture<Boolean> requestMultipart(final MultipartType multipartType,
149 final DeviceContext deviceContext) {
150 if (deviceContext.canUseSingleLayerSerialization()) {
151 final SingleLayerMultipartCollectorService service =
152 new SingleLayerMultipartCollectorService(deviceContext, deviceContext);
154 return Futures.transform(service.handleServiceCall(multipartType),
155 RpcResult::isSuccessful, MoreExecutors.directExecutor());
158 final MultiLayerMultipartCollectorService service =
159 new MultiLayerMultipartCollectorService(deviceContext, deviceContext);
161 return Futures.transform(service.handleServiceCall(multipartType),
162 RpcResult::isSuccessful, MoreExecutors.directExecutor());