openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/device/initialization/OF10DeviceInitializer.java

   1 /*
   2  * Copyright (c) 2017 Pantheon Technologies s.r.o. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.openflowplugin.impl.device.initialization;
   9
  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;
  48
  49 public class OF10DeviceInitializer extends AbstractDeviceInitializer {
  50
  51     private static final Logger LOG = LoggerFactory.getLogger(OF10DeviceInitializer.class);
  52
  53     @Override
  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();
  64
  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);
  69
  70         Futures.addCallback(future, new FutureCallback<Boolean>() {
  71             @Override
  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);
  76
  77                     LOG.debug("Creating empty tables for {}", deviceInfo);
  78                     DeviceInitializationUtil.makeEmptyTables(
  79                         deviceContext,
  80                         deviceInfo,
  81                         deviceContext.getPrimaryConnectionContext().getFeatures().getTables().toJava());
  82                 }
  83             }
  84
  85             @Override
  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);
  89             }
  90         }, MoreExecutors.directExecutor());
  91
  92         return Futures.transform(future, input -> {
  93             LOG.debug("Writing physical port information for {}", deviceInfo);
  94             writePhyPortInformation(deviceContext);
  95             return null;
  96         }, MoreExecutors.directExecutor());
  97     }
  98
  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
 104             .oook()
 105             .lookupTranslator(new TranslatorKey(deviceInfo.getVersion(), PortGrouping.class.getName()));
 106
 107         connectionContext.getFeatures().getPhyPort().forEach(port -> {
 108             final NodeConnectorId nodeConnectorId = InventoryDataServiceUtil.nodeConnectorIdfromDatapathPortNo(
 109                 deviceInfo.getDatapathId(),
 110                 port.getPortNo(),
 111                 OpenflowVersion.get(deviceInfo.getVersion()));
 112
 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);
 119             }
 120
 121             try {
 122                 deviceContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
 123                     deviceInfo
 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);
 129             }
 130         });
 131     }
 132
 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) {
 137         try {
 138             txFacade.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
 139                 deviceInfo
 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);
 145         }
 146     }
 147
 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);
 153
 154             return Futures.transform(service.handleServiceCall(multipartType),
 155                 RpcResult::isSuccessful, MoreExecutors.directExecutor());
 156         }
 157
 158         final MultiLayerMultipartCollectorService service =
 159                 new MultiLayerMultipartCollectorService(deviceContext, deviceContext);
 160
 161         return Futures.transform(service.handleServiceCall(multipartType),
 162             RpcResult::isSuccessful, MoreExecutors.directExecutor());
 163     }
 164
 165 }