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
9 package org.opendaylight.openflowplugin.impl.device.initialization;
11 import com.google.common.base.Function;
12 import com.google.common.base.Preconditions;
13 import com.google.common.util.concurrent.FutureCallback;
14 import com.google.common.util.concurrent.Futures;
15 import com.google.common.util.concurrent.ListenableFuture;
16 import com.google.common.util.concurrent.MoreExecutors;
17 import java.util.List;
18 import java.util.concurrent.Future;
19 import javax.annotation.Nonnull;
20 import javax.annotation.Nullable;
21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
22 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
23 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
24 import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
25 import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
26 import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator;
27 import org.opendaylight.openflowplugin.api.openflow.device.TxFacade;
28 import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey;
29 import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
30 import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProvider;
31 import org.opendaylight.openflowplugin.impl.services.multilayer.MultiLayerMultipartCollectorService;
32 import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerMultipartCollectorService;
33 import org.opendaylight.openflowplugin.impl.util.DeviceInitializationUtil;
34 import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
35 import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
36 import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReply;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.CapabilitiesV10;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsDataBuilder;
50 import org.opendaylight.yangtools.yang.common.RpcResult;
51 import org.slf4j.Logger;
52 import org.slf4j.LoggerFactory;
54 public class OF10DeviceInitializer extends AbstractDeviceInitializer {
56 private static final Logger LOG = LoggerFactory.getLogger(OF10DeviceInitializer.class);
59 protected Future<Void> initializeNodeInformation(@Nonnull final DeviceContext deviceContext,
60 final boolean switchFeaturesMandatory,
61 final boolean skipTableFeatures,
62 @Nullable final MultipartWriterProvider multipartWriterProvider,
63 @Nullable final ConvertorExecutor convertorExecutor) {
64 final ConnectionContext connectionContext =
65 Preconditions.checkNotNull(deviceContext.getPrimaryConnectionContext());
66 final DeviceState deviceState = Preconditions.checkNotNull(deviceContext.getDeviceState());
67 final DeviceInfo deviceInfo = Preconditions.checkNotNull(deviceContext.getDeviceInfo());
68 final CapabilitiesV10 capabilitiesV10 = connectionContext.getFeatures().getCapabilitiesV10();
70 // Set capabilities for this device based on capabilities of connection context
71 LOG.debug("Setting capabilities for device {}", deviceInfo);
72 DeviceStateUtil.setDeviceStateBasedOnV10Capabilities(deviceState, capabilitiesV10);
73 final ListenableFuture<Boolean> future = requestMultipart(MultipartType.OFPMPDESC, deviceContext);
75 Futures.addCallback(future, new FutureCallback<Boolean>() {
77 public void onSuccess(@Nullable final Boolean result) {
78 if (Boolean.TRUE.equals(result)) {
79 LOG.debug("Creating empty flow capable node: {}", deviceInfo);
80 makeEmptyFlowCapableNode(deviceContext, deviceInfo);
82 LOG.debug("Creating empty tables for {}", deviceInfo);
83 DeviceInitializationUtil.makeEmptyTables(
86 deviceContext.getPrimaryConnectionContext().getFeatures().getTables());
91 public void onFailure(@Nonnull final Throwable throwable) {
92 LOG.warn("Error occurred in preparation node {} for protocol 1.0", deviceInfo);
93 LOG.trace("Error for node {} : ", deviceInfo, throwable);
95 }, MoreExecutors.directExecutor());
97 return Futures.transform(future, new Function<Boolean, Void>() {
100 public Void apply(@Nullable final Boolean input) {
101 LOG.debug("Writing physical port information for {}", deviceInfo);
102 writePhyPortInformation(deviceContext);
108 @SuppressWarnings("checkstyle:IllegalCatch")
109 private static void writePhyPortInformation(final DeviceContext deviceContext) {
110 final DeviceInfo deviceInfo = deviceContext.getDeviceInfo();
111 final ConnectionContext connectionContext = deviceContext.getPrimaryConnectionContext();
112 final MessageTranslator<PortGrouping, FlowCapableNodeConnector> translator = deviceContext
114 .lookupTranslator(new TranslatorKey(deviceInfo.getVersion(), PortGrouping.class.getName()));
116 connectionContext.getFeatures().getPhyPort().forEach(port -> {
117 final NodeConnectorId nodeConnectorId = InventoryDataServiceUtil.nodeConnectorIdfromDatapathPortNo(
118 deviceInfo.getDatapathId(),
120 OpenflowVersion.get(deviceInfo.getVersion()));
123 deviceContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
125 .getNodeInstanceIdentifier()
126 .child(NodeConnector.class, new NodeConnectorKey(nodeConnectorId)),
127 new NodeConnectorBuilder()
128 .setId(nodeConnectorId)
130 FlowCapableNodeConnector.class,
131 translator.translate(port, deviceInfo, null))
133 FlowCapableNodeConnectorStatisticsData.class,
134 new FlowCapableNodeConnectorStatisticsDataBuilder().build())
136 } catch (final Exception e) {
137 LOG.debug("Failed to write node {} to DS ", deviceInfo, e);
142 @SuppressWarnings("checkstyle:IllegalCatch")
143 private static void makeEmptyFlowCapableNode(final TxFacade txFacade, final DeviceInfo deviceInfo) {
145 txFacade.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
147 .getNodeInstanceIdentifier()
148 .augmentation(FlowCapableNode.class),
149 new FlowCapableNodeBuilder().build());
150 } catch (final Exception e) {
151 LOG.debug("Failed to write empty node {} to DS ", deviceInfo, e);
155 private static ListenableFuture<Boolean> requestMultipart(final MultipartType multipartType,
156 final DeviceContext deviceContext) {
157 if (deviceContext.canUseSingleLayerSerialization()) {
158 final SingleLayerMultipartCollectorService service =
159 new SingleLayerMultipartCollectorService(deviceContext, deviceContext);
161 return Futures.transform(service.handleServiceCall(multipartType),
162 new Function<RpcResult<List<MultipartReply>>, Boolean>() {
165 public Boolean apply(final RpcResult<List<MultipartReply>> input) {
166 return input.isSuccessful();
171 final MultiLayerMultipartCollectorService service =
172 new MultiLayerMultipartCollectorService(deviceContext, deviceContext);
174 return Futures.transform(service.handleServiceCall(multipartType),
175 new Function<RpcResult<List<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol
176 .rev130731.MultipartReply>>, Boolean>() {
179 public Boolean apply(final RpcResult<List<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow
181 .rev130731.MultipartReply>> input) {
182 return input.isSuccessful();